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. நடைமுறையில், உங்கள் திட்டத்தின் நோக்கம் மற்றும் அளவின் அடிப்படையில் அவற்றை நெகிழ்வாகப் பயன்படுத்த வேண்டும்.