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. વ્યવહારમાં, તમારે તમારા પ્રોજેક્ટના હેતુ અને સ્કેલના આધારે તેમને લવચીક રીતે લાગુ કરવાની જરૂર પડશે.