Какие знаешь принципы SOLID

1️⃣ Как кратко ответить

SOLID — это набор из пяти принципов объектно-ориентированного программирования, которые помогают создавать более понятные, гибкие и поддерживаемые системы. Принципы включают: Single Responsibility Principle (SRP), Open/Closed Principle (OCP), Liskov Substitution Principle (LSP), Interface Segregation Principle (ISP) и Dependency Inversion Principle (DIP).

2️⃣ Подробное объяснение темы

SOLID — это акроним, который представляет собой пять принципов объектно-ориентированного программирования, разработанных для улучшения дизайна программного обеспечения. Эти принципы помогают разработчикам создавать системы, которые легче поддерживать и расширять. Рассмотрим каждый из них подробнее.

1. Single Responsibility Principle (SRP)

Каждый класс должен иметь только одну причину для изменения, то есть выполнять только одну задачу. Это упрощает понимание и поддержку кода, так как изменения в одной части системы не влияют на другие.

Пример:

// Плохой пример: класс выполняет несколько задач
class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }
​
  getUserInfo() {
    return `${this.name} (${this.email})`;
  }
​
  saveToDatabase() {
    // Логика сохранения в базу данных
  }
}
​
// Хороший пример: разделение ответственности
class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }
​
  getUserInfo() {
    return `${this.name} (${this.email})`;
  }
}
​
class UserRepository {
  save(user) {
    // Логика сохранения в базу данных
  }
}

2. Open/Closed Principle (OCP)

Классы должны быть открыты для расширения, но закрыты для модификации. Это означает, что поведение класса можно расширять без изменения его исходного кода.

Пример:

// Плохой пример: изменение существующего кода для добавления нового функционала
class Rectangle {
  constructor(width, height) {
    this.width = width;
    this.height = height;
  }
​
  area() {
    return this.width * this.height;
  }
}
​
// Хороший пример: использование наследования для расширения функционала
class Shape {
  area() {
    throw new Error('Method not implemented');
  }
}
​
class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
  }
​
  area() {
    return this.width * this.height;
  }
}
​
class Circle extends Shape {
  constructor(radius) {
    super();
    this.radius = radius;
  }
​
  area() {
    return Math.PI * this.radius * this.radius;
  }
}

3. Liskov Substitution Principle (LSP)

Объекты должны быть заменяемы экземплярами их подтипов без изменения корректности программы. Это гарантирует, что подклассы могут заменить базовые классы без изменения поведения программы.

Пример:

// Плохой пример: подкласс нарушает поведение базового класса
class Bird {
  fly() {
    console.log('Flying');
  }
}
​
class Penguin extends Bird {
  fly() {
    throw new Error('Penguins cannot fly');
  }
}
​
// Хороший пример: использование интерфейсов для разделения поведения
class Bird {
  layEgg() {
    console.log('Laying egg');
  }
}
​
class FlyingBird extends Bird {
  fly() {
    console.log('Flying');
  }
}
​
class Penguin extends Bird {
  swim() {
    console.log('Swimming');
  }
}

4. Interface Segregation Principle (ISP)

Клиенты не должны зависеть от интерфейсов, которые они не используют. Это означает, что лучше иметь несколько специализированных интерфейсов, чем один общий.

Пример:

// Плохой пример: один интерфейс для всех
class Worker {
  work() {
    // Работать
  }
​
  eat() {
    // Есть
  }
}
​
// Хороший пример: разделение интерфейсов
class Workable {
  work() {
    // Работать
  }
}
​
class Eatable {
  eat() {
    // Есть
  }
}
​
class Worker extends Workable, Eatable {
  work() {
    // Работать
  }
​
  eat() {
    // Есть
  }
}
​
class Robot extends Workable {
  work() {
    // Работать
  }
}

5. Dependency Inversion Principle (DIP)

Модули верхнего уровня не должны зависеть от модулей нижнего уровня. Оба должны зависеть от абстракций. Абстракции не должны зависеть от деталей. Детали должны зависеть от абстракций.

Пример:

// Плохой пример: зависимость от конкретной реализации
class LightBulb {
  turnOn() {
    console.log('LightBulb on');
  }
​
  turnOff() {
    console.log('LightBulb off');
  }
}
​
class Switch {
  constructor(lightBulb) {
    this.lightBulb = lightBulb;
  }
​
  operate() {
    this.lightBulb.turnOn();
  }
}
​
// Хороший пример: зависимость от абстракции
class Switchable {
  turnOn() {}
  turnOff() {}
}
​
class LightBulb extends Switchable {
  turnOn() {
    console.log('LightBulb on');
  }
​
  turnOff() {
    console.log('LightBulb off');
  }
}
​
class Switch {
  constructor(device) {
    this.device = device;
  }
​
  operate() {
    this.device.turnOn();
  }
}

Принципы SOLID помогают создавать более устойчивые и гибкие системы, которые легче поддерживать и расширять. Они особенно полезны в больших проектах, где сложность кода может быстро возрасти.