Stosowanie SOLID zasad w Node.js

Single Responsibility Principle(SRP)

Zasada ta mówi, że klasa powinna mieć tylko jeden powód do zmiany, co oznacza, że ​​każda klasa powinna pełnić określoną funkcję.

Przykład: Zarządzanie danymi użytkowników i wysyłanie email powiadomień.

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

Open/Closed Principle(OCP)

Ta zasada zachęca do rozszerzania funkcjonalności przez dodawanie nowego kodu zamiast modyfikowania istniejącego kodu.

Przykład: obsługa różnych metod płatności w aplikacji e-commerce.

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)

Zasada ta zakłada, że ​​obiekty klasy pochodnej powinny być zastępowalne obiektami klasy bazowej bez wpływu na poprawność programu.

Przykład: Zarządzanie kształtami geometrycznymi.

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;  
  }  
}  

Zasada segregacji interfejsów(ISP)

Ta zasada zaleca dzielenie interfejsów na mniejsze, aby uniknąć zmuszania klas do implementowania metod, których nie potrzebują.

Przykład: Interfejsy do aktualizacji i wyświetlania danych.

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

Dependency Inversion Principle(DIP)

Zasada ta sugeruje, że moduły wysokiego poziomu nie powinny zależeć od modułów niskiego poziomu; oba powinny zależeć od abstrakcji.

Przykład: Używanie dependency injection do zarządzania zależnościami.

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

Pamiętaj, że te przykłady to tylko przykłady zastosowania SOLID zasad zawartych w programie Node.js. W praktyce będziesz musiał stosować je elastycznie w zależności od celu i skali projektu.