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. ఆచరణలో, మీరు మీ ప్రాజెక్ట్ యొక్క ప్రయోజనం మరియు స్కేల్ ఆధారంగా వాటిని సరళంగా వర్తింపజేయాలి.