SOLID პრინციპების გამოყენება Node.js

Single Responsibility Principle(SRP)

ეს პრინციპი ამბობს, რომ კლასს უნდა ჰქონდეს ცვლილების მხოლოდ ერთი მიზეზი, რაც იმას ნიშნავს, რომ თითოეულმა კლასმა უნდა შეასრულოს კონკრეტული ფუნქცია.

მაგალითი: მომხმარებლის მონაცემების მართვა და email შეტყობინებების გაგზავნა.

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

Open/Closed Principle(OCP)

ეს პრინციპი ხელს უწყობს ფუნქციების გაფართოებას ახალი კოდის დამატებით, ვიდრე არსებული კოდის შეცვლით.

მაგალითი: გადახდის სხვადასხვა მეთოდის მართვა ელექტრონული კომერციის აპლიკაციაში.

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)

ეს პრინციპი ამტკიცებს, რომ მიღებული კლასის ობიექტები უნდა იყოს ჩანაცვლებადი საბაზისო კლასის ობიექტებით პროგრამის სისწორეზე გავლენის გარეშე.

მაგალითი: გეომეტრიული ფორმების მართვა.

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

ინტერფეისის სეგრეგაციის პრინციპი(ISP)

ეს პრინციპი გვირჩევს ინტერფეისების დაშლას უფრო პატარებად, რათა თავიდან აიცილოთ კლასების იძულება განახორციელონ მეთოდები, რომლებიც მათ არ სჭირდებათ.

მაგალითი: ინტერფეისები მონაცემთა განახლებისა და ჩვენებისთვის.

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

Dependency Inversion Principle(DIP)

ეს პრინციპი ვარაუდობს, რომ მაღალი დონის მოდულები არ უნდა იყოს დამოკიდებული დაბალი დონის მოდულებზე; ორივე უნდა იყოს დამოკიდებული აბსტრაქციებზე.

მაგალითი: გამოყენება dependency injection დამოკიდებულებების სამართავად.

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

დაიმახსოვრეთ, ეს მაგალითები მხოლოდ ილუსტრაციებია იმისა, თუ როგორ უნდა გამოიყენოთ SOLID პრინციპები Node.js. პრაქტიკაში, თქვენ უნდა გამოიყენოთ ისინი მოქნილად თქვენი პროექტის მიზნისა და მასშტაბის მიხედვით.