Anvendelse af SOLID principper i Node.js

Single Responsibility Principle(SRP)

Dette princip siger, at en klasse kun skal have én grund til at ændre sig, hvilket betyder, at hver klasse skal udføre en bestemt funktion.

Eksempel: Håndtering af brugerdata og afsendelse af email meddelelser.

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 princip tilskynder til at udvide funktionaliteten ved at tilføje ny kode i stedet for at ændre eksisterende kode.

Eksempel: Håndtering af forskellige betalingsmetoder i en e-handelsapplikation.

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 princip hævder, at objekter af en afledt klasse skal kunne substitueres med objekter i basisklassen uden at påvirke programmets korrekthed.

Eksempel: Håndtering af 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 princip råder til at opdele grænseflader i mindre for at undgå at tvinge klasser til at implementere metoder, de ikke har brug for.

Eksempel: Interfaces til opdatering og visning af data.

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

Dependency Inversion Principle(DIP)

Dette princip antyder, at højniveaumoduler ikke bør afhænge af lavniveaumoduler; begge burde afhænge af abstraktioner.

Eksempel: Brug dependency injection til at administrere afhængigheder.

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

Husk, at disse eksempler kun er illustrationer af, hvordan man anvender SOLID principperne i Node.js. I praksis bliver du nødt til at anvende dem fleksibelt baseret på formålet og omfanget af dit projekt.