Stosowanie SOLID zasad w Ruby: Przykłady i najlepsze praktyki

Single Responsibility Principle(SRP)

Zasada ta mówi, że każda klasa powinna mieć jedną odpowiedzialność. Podkreśla, że ​​klasa powinna pełnić jedną określoną funkcję i nie mieć zbyt wielu powodów do zmian.

Przykład: Zarządzanie informacjami o użytkownikach i wysyłanie powiadomień e-mail.

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)

Ta zasada zachęca do rozszerzania funkcjonalności przez dodawanie nowego kodu zamiast modyfikowania istniejącego kodu.

Przykład: obsługa różnych metod płatności w aplikacji e-commerce.

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)

Zasada ta zakłada, że ​​obiekty klasy pochodnej powinny być zastępowalne obiektami klasy bazowej bez wpływu na poprawność programu.

Przykład: Zarządzanie kształtami geometrycznymi.

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)

Ta zasada zaleca dzielenie interfejsów na mniejsze, aby uniknąć zmuszania klas do implementowania metod, których nie potrzebują.

Przykład: Interfejsy do aktualizacji i wyświetlania danych.

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)

Ta zasada sugeruje użycie iniekcji zależności do zarządzania zależnościami.

Przykład: Używanie wstrzykiwania zależności do zarządzania zależnościami.

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

Pamiętaj, że stosowanie SOLID zasad w Ruby powinno odbywać się elastycznie, w oparciu o konkretny cel twojego projektu oraz twoje zrozumienie SOLID i Ruby.