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. व्यवहारात, तुम्हाला तुमच्या प्रोजेक्टच्या उद्देश आणि स्केलच्या आधारावर ते लवचिकपणे लागू करणे आवश्यक आहे.