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

Single Responsibility Principle(SRP)

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

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

class UserManager  
  def create_user(user_data)  
    # Logic for creating a user  
  end  
end  
  
class EmailService  
  def send_email(email_data)  
    # Logic for sending an email  
  end  
end  

Open/Closed Principle(OCP)

આ સિદ્ધાંત હાલના કોડમાં ફેરફાર કરવાને બદલે નવો કોડ ઉમેરીને કાર્યક્ષમતાને વિસ્તૃત કરવા પ્રોત્સાહિત કરે છે.

ઉદાહરણ: ઈ-કોમર્સ એપ્લિકેશનમાં વિવિધ ચુકવણી પદ્ધતિઓનું સંચાલન કરવું.

class PaymentProcessor  
  def process_payment  
    # Common logic for payment processing  
  end  
end  
  
class CreditCardPaymentProcessor < PaymentProcessor  
  def process_payment  
    # Logic for processing credit card payment  
  end  
end  
  
class PayPalPaymentProcessor < PaymentProcessor  
  def process_payment  
    # Logic for processing PayPal payment  
  end  
end  

Liskov Substitution Principle(LSP)

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

ઉદાહરણ: ભૌમિતિક આકારોનું સંચાલન.

class Shape  
  def area  
    # Common logic for calculating area  
  end  
end  
  
class Rectangle < Shape  
  def area  
    # Logic for calculating area of rectangle  
  end  
end  
  
class Square < Shape  
  def area  
    # Logic for calculating area of square  
  end  
end  

Interface Segregation Principle(ISP)

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

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

module UpdateableFeature  
  def update_feature  
    # Logic for updating feature  
  end  
end  
  
module DisplayableFeature  
  def display_feature  
    # Logic for displaying feature  
  end  
end  

Dependency Inversion Principle(DIP)

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

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

class OrderProcessor  
  def initialize(db_connection, email_service)  
    @db_connection = db_connection  
    @email_service = email_service  
  end  
end  

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