Anvendelse av SOLID prinsipper i Node.js

Single Responsibility Principle(SRP)

Dette prinsippet sier at en klasse bare skal ha én grunn til å endre seg, noe som betyr at hver klasse skal utføre en spesifikk funksjon.

Eksempel: Administrere brukerdata og sende email varsler.

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

Open/Closed Principle(OCP)

Dette prinsippet oppmuntrer til å utvide funksjonaliteten ved å legge til ny kode i stedet for å endre eksisterende kode.

Eksempel: Håndtering av ulike betalingsmåter i en e-handelsapplikasjon.

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)

Dette prinsippet hevder at objekter av en avledet klasse skal kunne erstattes med objekter i basisklassen uten å påvirke programmets korrekthet.

Eksempel: Håndtering av geometriske former.

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

nterface Segregation Principle(ISP)

Dette prinsippet anbefaler å dele grensesnitt i mindre for å unngå å tvinge klasser til å implementere metoder de ikke trenger.

Eksempel: Grensesnitt for oppdatering og visning av data.

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

Dependency Inversion Principle(DIP)

Dette prinsippet antyder at høynivåmoduler ikke bør være avhengig av lavnivåmoduler; begge bør avhenge av abstraksjoner.

Eksempel: Bruk dependency injection til å administrere avhengigheter.

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

Husk at disse eksemplene bare er illustrasjoner av hvordan du bruker SOLID prinsippene i Node.js. I praksis må du bruke dem fleksibelt basert på formålet og omfanget av prosjektet ditt.