Menerapkan SOLID Prinsip dalam Node.js

Single Responsibility Principle(SRP)

Prinsip ini menyatakan bahawa kelas harus mempunyai hanya satu sebab untuk berubah, bermakna setiap kelas harus melaksanakan fungsi tertentu.

Contoh: Mengurus data pengguna dan menghantar email pemberitahuan.

class UserManager {  
  constructor() {}  
    
  createUser(userData) {  
    // Logic for creating a user  
  }  
}  
  
class EmailService {  
  constructor() {}  
    
  sendEmail(emailData) {  
    // Logic for sending an email  
  }  
}  

Open/Closed Principle(OCP)

Prinsip ini menggalakkan memperluaskan fungsi dengan menambah kod baharu dan bukannya mengubah suai kod sedia ada.

Contoh: Mengendalikan kaedah pembayaran yang berbeza dalam aplikasi e-dagang.

class PaymentProcessor {  
  processPayment() {  
    // Common logic for payment processing  
  }  
}  
  
class CreditCardPaymentProcessor extends PaymentProcessor {  
  processPayment() {  
    // Logic for processing credit card payment  
  }  
}  
  
class PayPalPaymentProcessor extends PaymentProcessor {  
  processPayment() {  
    // Logic for processing PayPal payment  
  }  
}  

Liskov Substitution Principle(LSP)

Prinsip ini menegaskan bahawa objek kelas terbitan harus digantikan untuk objek kelas asas tanpa menjejaskan ketepatan program.

Contoh: Menguruskan bentuk geometri.

class Shape {  
  area() {}  
}  
  
class Rectangle extends Shape {  
  constructor(width, height) {}  
    
  area() {  
    return this.width * this.height;  
  }  
}  
  
class Square extends Shape {  
  constructor(side) {}  
    
  area() {  
    return this.side * this.side;  
  }  
}  

Prinsip Pengasingan antara muka(ISP)

Prinsip ini menasihatkan memecahkan antara muka kepada yang lebih kecil untuk mengelakkan memaksa kelas melaksanakan kaedah yang mereka tidak perlukan.

Contoh: Antara muka untuk mengemas kini dan memaparkan data.

class UpdateableFeature {  
  updateFeature() {}  
}  
  
class DisplayableFeature {  
  displayFeature() {}  
}  

Dependency Inversion Principle(DIP)

Prinsip ini mencadangkan bahawa modul peringkat tinggi tidak boleh bergantung pada modul peringkat rendah; kedua-duanya harus bergantung pada abstraksi.

Contoh: Menggunakan dependency injection untuk mengurus tanggungan.

class OrderProcessor {  
  constructor(dbConnection, emailService) {  
    this.dbConnection = dbConnection;  
    this.emailService = emailService;  
  }  
}  

Ingat, contoh ini hanyalah ilustrasi tentang cara menggunakan SOLID prinsip dalam Node.js. Dalam amalan, anda perlu menerapkannya secara fleksibel berdasarkan tujuan dan skala projek anda.