SOLID માં સિદ્ધાંતો લાગુ કરવા JavaScript: ઉદાહરણો અને શ્રેષ્ઠ વ્યવહારો

Single Responsibility Principle(SRP)

આ સિદ્ધાંત જણાવે છે કે દરેક વર્ગની એક જ જવાબદારી હોવી જોઈએ. તે ભાર મૂકે છે કે વર્ગે એક ચોક્કસ કાર્ય કરવું જોઈએ અને તેને બદલવા માટે ઘણા બધા કારણો ન હોવા જોઈએ.

ઉદાહરણ: વપરાશકર્તાની માહિતીનું સંચાલન કરવું અને ઇમેઇલ સૂચનાઓ મોકલવી.

class UserManager {  
  createUser(userData) {  
    // Logic for creating a user  
  }  
}  
  
class EmailService {  
  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() {  
    // Common logic for calculating area  
  }  
}  
  
class Rectangle extends Shape {  
  area() {  
    // Logic for calculating area of rectangle  
  }  
}  
  
class Square extends Shape {  
  area() {  
    // Logic for calculating area of square  
  }  
}  

Interface Segregation Principle(ISP)

આ સિદ્ધાંત વર્ગોને જરૂરી ન હોય તેવી પદ્ધતિઓ અમલમાં મૂકવા માટે દબાણ કરવાનું ટાળવા માટે ઇન્ટરફેસને નાનામાં વિભાજીત કરવાની સલાહ આપે છે.

ઉદાહરણ: ડેટાને અપડેટ કરવા અને પ્રદર્શિત કરવા માટેના ઇન્ટરફેસ.

class UpdateableFeature {  
  updateFeature() {  
    // Logic for updating feature  
  }  
}  
  
class DisplayableFeature {  
  displayFeature() {  
    // Logic for displaying feature  
  }  
}  

Dependency Inversion Principle(DIP)

આ સિદ્ધાંત નિર્ભરતાને સંચાલિત કરવા માટે નિર્ભરતા ઇન્જેક્શનનો ઉપયોગ કરવાનું સૂચવે છે.

ઉદાહરણ: નિર્ભરતાને સંચાલિત કરવા માટે નિર્ભરતા ઇન્જેક્શનનો ઉપયોગ કરવો.

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

યાદ રાખો કે SOLID માં સિદ્ધાંતો લાગુ કરવાનું તમારા પ્રોજેક્ટના વિશિષ્ટ હેતુ અને અને અને JavaScript વિશેની તમારી સમજના આધારે લવચીક રીતે થવું જોઈએ. SOLID JavaScript