Application SOLID des principes dans Node.js

Single Responsibility Principle(SRP)

Ce principe stipule qu'une classe ne doit avoir qu'une seule raison de changer, ce qui signifie que chaque classe doit remplir une fonction spécifique.

Exemple: gestion des données utilisateur et envoi email de notifications.

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

Open/Closed Principle(OCP)

Ce principe encourage l'extension des fonctionnalités en ajoutant du nouveau code plutôt qu'en modifiant le code existant.

Exemple: Gestion de différents modes de paiement dans une application 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)

Ce principe affirme que les objets d'une classe dérivée doivent être substituables aux objets de la classe de base sans affecter l'exactitude du programme.

Exemple: Gestion des formes géométriques.

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

Principe de séparation des interfaces(ISP)

Ce principe conseille de diviser les interfaces en plus petites afin d'éviter de forcer les classes à implémenter des méthodes dont elles n'ont pas besoin.

Exemple: Interfaces de mise à jour et d'affichage des données.

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

Dependency Inversion Principle(DIP)

Ce principe suggère que les module de haut niveau ne doivent pas dépendre des module de bas niveau ; les deux devraient dépendre d'abstractions.

Exemple: Utilisation dependency injection pour gérer les dépendances.

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

N'oubliez pas que ces exemples ne sont que des illustrations de la manière d'appliquer les SOLID principes de Node.js. En pratique, vous devrez les appliquer avec souplesse en fonction de l'objectif et de l'ampleur de votre projet.