SOLID Principes toepassen in Node.js

Single Responsibility Principle(SRP)

Dit principe stelt dat een klasse maar één reden mag hebben om te veranderen, wat inhoudt dat elke klasse een specifieke functie moet vervullen.

Voorbeeld: Gebruikersgegevens beheren en email notificaties versturen.

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

Open/Closed Principle(OCP)

Dit principe moedigt uitbreiding van functionaliteit aan door nieuwe code toe te voegen in plaats van bestaande code te wijzigen.

Voorbeeld: Afhandelen van verschillende betaalmethodes in een e-commerce applicatie.

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)

Dit principe stelt dat objecten van een afgeleide klasse substitueerbaar moeten zijn voor objecten van de basisklasse zonder de correctheid van het programma aan te tasten.

Voorbeeld: geometrische vormen beheren.

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

ninterface-segregatieprincipe(ISP)

Dit principe raadt aan om interfaces op te splitsen in kleinere om te voorkomen dat klassen gedwongen worden methoden te implementeren die ze niet nodig hebben.

Voorbeeld: Interfaces voor het bijwerken en weergeven van gegevens.

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

Dependency Inversion Principle(DIP)

Dit principe suggereert dat module op hoog niveau niet afhankelijk mogen zijn van module op laag niveau; beide zouden afhankelijk moeten zijn van abstracties.

Voorbeeld: gebruiken dependency injection om afhankelijkheden te beheren.

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

Onthoud dat deze voorbeelden slechts illustraties zijn van hoe de SOLID principes in Node.js. In de praktijk zult u ze flexibel moeten toepassen op basis van het doel en de schaal van uw project.