SOLID: принципы объектно-ориентированного проектирования с примерами на JavaScript

Почему принципы SOLID важны для современной JavaScript-разработки?

В мире, где JavaScript превратился из простого языка для веб-страниц в мощную платформу для создания сложных приложений, хорошая архитектура кода играет решающую роль. Принципы SOLID, изначально разработанные Робертом Мартином для языков со строгой типизацией, стали универсальным фундаментом качественной разработки и в экосистеме JavaScript.

Применение SOLID в JavaScript-проектах позволяет:

• 🔧 Упростить сопровождение кода — изменения вносятся локально, без каскадных правок
• 🧩 Повысить возможность повторного использования компонентов — модули становятся автономными
• 🧪 Улучшить тестируемость — изолированные компоненты проще покрыть тестами
• 🚀 Ускорить разработку — четкие правила проектирования снижают технический долг
• 👥 Облегчить командную работу — согласованные принципы упрощают взаимодействие

Что такое SOLID?

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

• S: Single Responsibility Principle (Принцип единственной ответственности)
• O: Open/Closed Principle (Принцип открытости/закрытости)
• L: Liskov Substitution Principle (Принцип подстановки Лисков)
• I: Interface Segregation Principle (Принцип разделения интерфейса)
• D: Dependency Inversion Principle (Принцип инверсии зависимостей)

Давайте рассмотрим каждый принцип и его применение в JavaScript-разработке с практическими примерами.

S: Принцип единственной ответственности (Single Responsibility Principle)

"Класс должен иметь только одну причину для изменения."

Этот принцип означает, что модуль (класс, функция, компонент) должен отвечать только за одну функциональность или задачу. Если модуль имеет несколько ответственностей, это усложняет его понимание, тестирование и модификацию.

Пример нарушения принципа

// Плохой пример: класс имеет несколько ответственностей
class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }

  // Ответственность 1: Работа с данными пользователя
  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }

  getEmail() {
    return this.email;
  }

  setEmail(email) {
    this.email = email;
  }

  // Ответственность 2: Валидация данных
  validateEmail(email) {
    const re = /\S+@\S+\.\S+/;
    return re.test(email);
  }

  // Ответственность 3: Сохранение в базу данных
  saveToDatabase() {
    // Код для сохранения пользователя в БД
    console.log(`Saving user ${this.name} to database`);
  }

  // Ответственность 4: Отправка уведомлений
  sendWelcomeEmail() {
    // Код для отправки приветственного письма
    console.log(`Sending welcome email to ${this.email}`);
  }
}

// Использование
const user = new User('John Doe', 'john@example.com');
user.saveToDatabase();
user.sendWelcomeEmail();

В этом примере класс User выполняет несколько несвязанных функций: хранит данные пользователя, валидирует их, сохраняет в базу данных и отправляет уведомления. Это нарушает принцип SRP.

Пример соблюдения принципа

// Хороший пример: разделение ответственности по отдельным классам

// Ответственность 1: Модель данных пользователя
class User {
  constructor(name, email) {
    this.name = name;
    this.email = email;
  }

  getName() {
    return this.name;
  }

  setName(name) {
    this.name = name;
  }

  getEmail() {
    return this.email;
  }

  setEmail(email) {
    this.email = email;
  }
}

// Ответственность 2: Валидация данных
class UserValidator {
  static validateEmail(email) {
    const re = /\S+@\S+\.\S+/;
    return re.test(email);
  }

  static validateName(name) {
    return name.trim().length > 0;
  }
}

// Ответственность 3: Сохранение в базу данных
class UserRepository {
  saveUser(user) {
    // Код для сохранения пользователя в БД
    console.log(`Saving user ${user.getName()} to database`);
  }

  findUserByEmail(email) {
    // Код для поиска пользователя в БД
    console.log(`Finding user by email: ${email}`);
    return null; // предположим, что пользователь не найден
  }
}

// Ответственность 4: Отправка уведомлений
class UserNotifier {
  sendWelcomeEmail(user) {
    // Код для отправки приветственного письма
    console.log(`Sending welcome email to ${user.getEmail()}`);
  }

  sendPasswordResetEmail(user) {
    // Код для отправки письма с сбросом пароля
    console.log(`Sending password reset email to ${user.getEmail()}`);
  }
}

// Использование
const user = new User('John Doe', 'john@example.com');

if (UserValidator.validateEmail(user.getEmail()) &&
  UserValidator.validateName(user.getName())) {
  const repository = new UserRepository();
  repository.saveUser(user);

  const notifier = new UserNotifier();
  notifier.sendWelcomeEmail(user);
}

В этом улучшенном примере мы разделили ответственность на четыре разных класса, каждый из которых выполняет только одну задачу:

• User — модель данных пользователя
• UserValidator — валидация данных пользователя
• UserRepository — взаимодействие с базой данных
• UserNotifier — отправка уведомлений

Применение SRP в функциональном JavaScript

Принцип единственной ответственности также применим к функциональному программированию:

// Функциональный подход с соблюдением SRP

// Функция только для создания объекта пользователя
const createUser = (name, email) => ({ name, email });

// Функция только для валидации email
const isValidEmail = (email) => {
  const re = /\S+@\S+\.\S+/;
  return re.test(email);
};

// Функция только для валидации имени
const isValidName = (name) => name.trim().length > 0;

// Функция только для сохранения в БД
const saveUserToDatabase = (user) => {
  console.log(`Saving user ${user.name} to database`);
  return user; // Возвращаем пользователя для возможности цепочки вызовов
};

// Функция только для отправки уведомления
const sendWelcomeEmail = (user) => {
  console.log(`Sending welcome email to ${user.email}`);
  return user; // Возвращаем пользователя для возможности цепочки вызовов
};

// Использование в функциональном стиле
const user = createUser('John Doe', 'john@example.com');

if (isValidEmail(user.email) && isValidName(user.name)) {
  // Композиция функций
  const processUser = (user) =>
    sendWelcomeEmail(saveUserToDatabase(user));

  processUser(user);
}

Пройди собеседование в топ-компанию

Платформа для подготовки

Решай алгоритмические задачи как профи

✓ Популярные алгоритмы✓ Разбор решений✓ AI помощь

Начать сейчас→

O: Принцип открытости/закрытости (Open/Closed Principle)

"Программные сущности должны быть открыты для расширения, но закрыты для модификации."

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

Пример нарушения принципа

// Плохой пример: нарушение принципа открытости/закрытости

class Rectangle {
  constructor(width, height) {
    this.width = width;
    this.height = height;
  }
}

class Circle {
  constructor(radius) {
    this.radius = radius;
  }
}

// Эта функциональность нарушает OCP, так как для каждого нового типа фигуры
// придется изменять код класса, добавляя новые условия
class AreaCalculator {
  calculateArea(shapes) {
    let area = 0;

    for (const shape of shapes) {
      if (shape instanceof Rectangle) {
        // Расчет для прямоугольника
        area += shape.width * shape.height;
      } else if (shape instanceof Circle) {
        // Расчет для круга
        area += Math.PI * shape.radius ** 2;
      }
      // Если добавим новую фигуру, придется изменять этот метод!
    }

    return area;
  }
}

// Использование
const rectangle = new Rectangle(5, 4);
const circle = new Circle(3);
const calculator = new AreaCalculator();
const totalArea = calculator.calculateArea([rectangle, circle]);
console.log(`Total area: ${totalArea}`);

В этом примере для добавления нового типа фигуры (например, треугольника) нам придется изменять метод calculateArea в классе AreaCalculator, что нарушает принцип OCP.

Пример соблюдения принципа

// Хороший пример: соблюдение принципа открытости/закрытости

// Базовый класс или интерфейс
class Shape {
  calculateArea() {
    throw new Error('Method calculateArea() must be implemented');
  }
}

class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
  }

  calculateArea() {
    return this.width * this.height;
  }
}

class Circle extends Shape {
  constructor(radius) {
    super();
    this.radius = radius;
  }

  calculateArea() {
    return Math.PI * this.radius ** 2;
  }
}

// Теперь этот класс закрыт для изменений, но открыт для расширения
class AreaCalculator {
  calculateArea(shapes) {
    return shapes.reduce((sum, shape) => {
      if (!(shape instanceof Shape)) {
        throw new Error('Invalid shape type');
      }
      return sum + shape.calculateArea();
    }, 0);
  }
}

// Использование
const rectangle = new Rectangle(5, 4);
const circle = new Circle(3);
const calculator = new AreaCalculator();
const totalArea = calculator.calculateArea([rectangle, circle]);
console.log(`Total area: ${totalArea}`);

// Расширяем функциональность, добавляя новую фигуру, не изменяя существующий код
class Triangle extends Shape {
  constructor(base, height) {
    super();
    this.base = base;
    this.height = height;
  }

  calculateArea() {
    return 0.5 * this.base * this.height;
  }
}

// Использование с новым типом
const triangle = new Triangle(6, 4);
const newTotalArea = calculator.calculateArea([rectangle, circle, triangle]);
console.log(`New total area: ${newTotalArea}`);

В этом примере мы используем полиморфизм для соблюдения принципа OCP. Базовый класс Shape определяет интерфейс с методом calculateArea(), а все конкретные фигуры реализуют этот метод. Теперь мы можем добавлять новые фигуры, не изменяя класс AreaCalculator.

Применение OCP с использованием паттерна "Стратегия"

Альтернативный способ соблюдения OCP — использование паттерна "Стратегия", особенно полезного в функциональном JavaScript:

// Применение OCP с паттерном "Стратегия"

// Объект с функциями-стратегиями
const areaStrategies = {
  rectangle: (shape) => shape.width * shape.height,
  circle: (shape) => Math.PI * shape.radius ** 2,
  triangle: (shape) => 0.5 * shape.base * shape.height
};

// Функция, которая использует соответствующую стратегию
const calculateArea = (shape) => {
  if (!shape.type || !areaStrategies[shape.type]) {
    throw new Error(`Cannot calculate area of: ${shape}`);
  }

  return areaStrategies[shape.type](shape);
};

// Создание объектов фигур
const rectangle = { type: 'rectangle', width: 5, height: 4 };
const circle = { type: 'circle', radius: 3 };

// Использование
const totalArea = [rectangle, circle].reduce(
  (sum, shape) => sum + calculateArea(shape), 0
);
console.log(`Total area: ${totalArea}`);

// Добавление новой стратегии без изменения существующего кода
areaStrategies.square = (shape) => shape.side ** 2;

// Использование с новым типом
const square = { type: 'square', side: 5 };
const newTotalArea = [rectangle, circle, square].reduce(
  (sum, shape) => sum + calculateArea(shape), 0
);
console.log(`New total area: ${newTotalArea}`);

L: Принцип подстановки Лисков (Liskov Substitution Principle)

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

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

Пример нарушения принципа

// Плохой пример: нарушение принципа подстановки Лисков

class Rectangle {
  constructor(width, height) {
    this.width = width;
    this.height = height;
  }

  setWidth(width) {
    this.width = width;
  }

  setHeight(height) {
    this.height = height;
  }

  getArea() {
    return this.width * this.height;
  }
}

// Квадрат наследуется от прямоугольника
class Square extends Rectangle {
  constructor(side) {
    super(side, side);
  }

  // Переопределяем методы, чтобы сохранить инвариант квадрата
  setWidth(width) {
    this.width = width;
    this.height = width; // Нарушение LSP: изменяет поведение
  }

  setHeight(height) {
    this.width = height; // Нарушение LSP: изменяет поведение
    this.height = height;
  }
}

// Функция, ожидающая работать с прямоугольником
function enlargeRectangle(rectangle) {
  rectangle.setWidth(rectangle.width + 1);
  rectangle.setHeight(rectangle.height + 1);
  return rectangle.getArea();
}

// Использование
const rectangle = new Rectangle(3, 4);
console.log(enlargeRectangle(rectangle)); // 20 (4*5)

const square = new Square(3);
console.log(enlargeRectangle(square)); // 25 (5*5) - неожиданное поведение!

В этом примере функция enlargeRectangle рассчитывает, что увеличение ширины и высоты прямоугольника приведет к увеличению площади на определенную величину. Однако, из-за переопределения методов setWidth и setHeight в классе Square, поведение не соответствует ожиданиям, что нарушает принцип LSP.

Пример соблюдения принципа

// Хороший пример: соблюдение принципа подстановки Лисков

// Базовый класс для всех геометрических фигур
class Shape {
  getArea() {
    throw new Error('Method getArea() must be implemented');
  }
}

class Rectangle extends Shape {
  constructor(width, height) {
    super();
    this.width = width;
    this.height = height;
  }

  getArea() {
    return this.width * this.height;
  }
}

class Square extends Shape {
  constructor(side) {
    super();
    this.side = side;
  }

  getArea() {
    return this.side ** 2;
  }
}

// Функция, работающая с любыми фигурами
function printArea(shape) {
  console.log(`Area: ${shape.getArea()}`);
}

// Использование
const rectangle = new Rectangle(3, 4);
printArea(rectangle); // Area: 12

const square = new Square(3);
printArea(square); // Area: 9

// Функция, специфичная для прямоугольников
function enlargeRectangle(rectangle) {
  if (!(rectangle instanceof Rectangle)) {
    throw new Error('Rectangle expected');
  }

  const newRect = new Rectangle(
    rectangle.width + 1,
    rectangle.height + 1
  );

  return newRect.getArea();
}

console.log(enlargeRectangle(rectangle)); // 20
// console.log(enlargeRectangle(square)); // Ошибка, что правильно!

В этом примере мы перепроектировали иерархию классов так, чтобы Square и Rectangle наследовались от общего абстрактного класса Shape, а не друг от друга. Теперь функция printArea работает с любой фигурой, а функция enlargeRectangle специфична только для прямоугольников, что обеспечивает корректное поведение.

Применение LSP в функциональном JavaScript

В функциональном подходе принцип LSP может быть соблюден через использование функций с одинаковой сигнатурой:

// Применение LSP в функциональном стиле

// Функции для вычисления площади
const rectangleArea = (rect) => rect.width * rect.height;
const squareArea = (square) => square.side ** 2;

// Функции для создания фигур
const createRectangle = (width, height) => ({
  type: 'rectangle',
  width,
  height,
  getArea: function() { return rectangleArea(this); }
});

const createSquare = (side) => ({
  type: 'square',
  side,
  getArea: function() { return squareArea(this); }
});

// Функция, которая может работать с любой фигурой, имеющей метод getArea
const printArea = (shape) => {
  console.log(`Area: ${shape.getArea()}`);
};

// Использование
const rectangle = createRectangle(3, 4);
const square = createSquare(3);

printArea(rectangle); // Area: 12
printArea(square); // Area: 9

I: Принцип разделения интерфейса (Interface Segregation Principle)

"Много специализированных интерфейсов лучше, чем один универсальный."

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

Пример нарушения принципа

// Плохой пример: нарушение принципа разделения интерфейса

// Большой и громоздкий интерфейс, который не все классы могут полностью реализовать
class Printer {
  print(document) {
    throw new Error('Method print() must be implemented');
  }

  scan(document) {
    throw new Error('Method scan() must be implemented');
  }

  fax(document) {
    throw new Error('Method fax() must be implemented');
  }

  copyDocument() {
    throw new Error('Method copyDocument() must be implemented');
  }
}

// Этот класс должен реализовать все методы, даже те, которые не использует
class OldPrinter extends Printer {
  print(document) {
    console.log('Printing document...');
  }

  // Вынуждены реализовать методы, но старый принтер не умеет сканировать
  scan(document) {
    throw new Error('This printer cannot scan!');
  }

  // Вынуждены реализовать методы, но старый принтер не умеет отправлять факсы
  fax(document) {
    throw new Error('This printer cannot fax!');
  }

  // Вынуждены реализовать методы, но старый принтер не умеет копировать
  copyDocument() {
    throw new Error('This printer cannot copy!');
  }
}

// Использование
const oldPrinter = new OldPrinter();
oldPrinter.print('document');
// oldPrinter.scan('document'); // Выбросит ошибку, что не интуитивно

В этом примере класс OldPrinter вынужден реализовать все методы интерфейса Printer, хотя на самом деле поддерживает только печать.

Пример соблюдения принципа

// Хороший пример: соблюдение принципа разделения интерфейса

// Разделяем интерфейс на более мелкие, специализированные
class Printer {
  print(document) {
    throw new Error('Method print() must be implemented');
  }
}

class Scanner {
  scan(document) {
    throw new Error('Method scan() must be implemented');
  }
}

class Fax {
  fax(document) {
    throw new Error('Method fax() must be implemented');
  }
}

class Copier {
  copyDocument() {
    throw new Error('Method copyDocument() must be implemented');
  }
}

// Простой принтер реализует только нужный ему интерфейс
class SimplePrinter extends Printer {
  print(document) {
    console.log('Printing document...');
  }
}

// Многофункциональное устройство реализует все интерфейсы
class AllInOnePrinter extends Printer {
  constructor() {
    super();
    this.scanner = new ScannerImpl();
    this.faxDevice = new FaxImpl();
    this.copier = new CopierImpl();
  }

  print(document) {
    console.log('Printing document...');
  }

  scan(document) {
    this.scanner.scan(document);
  }

  fax(document) {
    this.faxDevice.fax(document);
  }

  copyDocument() {
    this.copier.copyDocument();
  }
}

// Конкретные реализации для композиции
class ScannerImpl extends Scanner {
  scan(document) {
    console.log('Scanning document...');
  }
}

class FaxImpl extends Fax {
  fax(document) {
    console.log('Sending fax...');
  }
}

class CopierImpl extends Copier {
  copyDocument() {
    console.log('Copying document...');
  }
}

// Использование
const simplePrinter = new SimplePrinter();
simplePrinter.print('document'); // Работает только печать, что ожидаемо

const allInOnePrinter = new AllInOnePrinter();
allInOnePrinter.print('document');
allInOnePrinter.scan('document');
allInOnePrinter.fax('document');
allInOnePrinter.copyDocument();

В этом примере мы разделили большой интерфейс на более мелкие, специализированные. Теперь каждый класс может реализовать только те интерфейсы, которые ему нужны. Для сложного устройства мы используем композицию, чтобы объединить функциональность.

Применение ISP в JavaScript с использованием примесей (mixins)

В JavaScript принцип ISP можно реализовать с помощью примесей (mixins):

// Применение ISP с использованием примесей (mixins)

// Определяем примеси для разных функциональностей
const PrinterMixin = {
  print(document) {
    console.log(`Printing ${document}`);
  }
};

const ScannerMixin = {
  scan(document) {
    console.log(`Scanning ${document}`);
  }
};

const FaxMixin = {
  fax(document) {
    console.log(`Faxing ${document}`);
  }
};

const CopierMixin = {
  copy() {
    console.log('Copying document');
  }
};

// Создаем класс, использующий только нужные примеси
class SimplePrinter {
  constructor(name) {
    this.name = name;
  }
}
// Расширяем только нужной функциональностью
Object.assign(SimplePrinter.prototype, PrinterMixin);

// Многофункциональное устройство
class AllInOnePrinter {
  constructor(name) {
    this.name = name;
  }
}
// Расширяем всеми функциональностями
Object.assign(
  AllInOnePrinter.prototype,
  PrinterMixin,
  ScannerMixin,
  FaxMixin,
  CopierMixin
);

// Использование
const simplePrinter = new SimplePrinter('HP Basic');
simplePrinter.print('document.pdf');
// simplePrinter.scan('document.pdf'); // Ошибка: метод не существует

const allInOnePrinter = new AllInOnePrinter('HP Advanced');
allInOnePrinter.print('document.pdf');
allInOnePrinter.scan('document.pdf');
allInOnePrinter.fax('document.pdf');
allInOnePrinter.copy();

D: Принцип инверсии зависимостей (Dependency Inversion Principle)

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

Этот принцип направлен на уменьшение связанности между компонентами системы. Высокоуровневые модули должны зависеть от абстракций, а не от конкретных реализаций.

Пример нарушения принципа

// Плохой пример: нарушение принципа инверсии зависимостей

// Низкоуровневый модуль
class MySQLDatabase {
  connect() {
    console.log('Connecting to MySQL database...');
  }
  
  query(sql) {
    console.log(`Executing MySQL query: ${sql}`);
    return [/* некоторые данные */];
  }
  
  disconnect() {
    console.log('Disconnecting from MySQL database...');
  }
}

// Высокоуровневый модуль зависит от конкретной реализации MySQLDatabase
class UserService {
  constructor() {
    this.database = new MySQLDatabase(); // Жёсткая зависимость от конкретной реализации
  }
  
  getUsers() {
    this.database.connect();
    const users = this.database.query('SELECT * FROM users');
    this.database.disconnect();
    return users;
  }
  
  getUserById(id) {
    this.database.connect();
    const user = this.database.query(`SELECT * FROM users WHERE id = ${id}`);
    this.database.disconnect();
    return user;
  }
}

// Использование
const userService = new UserService();
const users = userService.getUsers();

В этом примере класс UserService напрямую зависит от конкретной реализации MySQLDatabase. Если мы захотим поменять базу данных, например, на MongoDB или PostgreSQL, нам придется переписывать UserService.

Пример соблюдения принципа

// Хороший пример: соблюдение принципа инверсии зависимостей

// Определяем абстракцию (интерфейс) для работы с базой данных
class Database {
  connect() {
    throw new Error('Method connect() must be implemented');
  }
  
  query(sql) {
    throw new Error('Method query() must be implemented');
  }
  
  disconnect() {
    throw new Error('Method disconnect() must be implemented');
  }
}

// Конкретная реализация для MySQL
class MySQLDatabase extends Database {
  connect() {
    console.log('Connecting to MySQL database...');
  }
  
  query(sql) {
    console.log(`Executing MySQL query: ${sql}`);
    return [/* некоторые данные */];
  }
  
  disconnect() {
    console.log('Disconnecting from MySQL database...');
  }
}

// Конкретная реализация для MongoDB
class MongoDatabase extends Database {
  connect() {
    console.log('Connecting to MongoDB...');
  }
  
  query(filter) {
    console.log(`Executing MongoDB query with filter: ${JSON.stringify(filter)}`);
    return [/* некоторые данные */];
  }
  
  disconnect() {
    console.log('Disconnecting from MongoDB...');
  }
}

// Высокоуровневый модуль зависит от абстракции
class UserService {
  constructor(database) {
    this.database = database; // Зависимость от абстракции через инъекцию зависимости
  }
  
  getUsers() {
    this.database.connect();
    const users = this.database.query('SELECT * FROM users');
    this.database.disconnect();
    return users;
  }
  
  getUserById(id) {
    this.database.connect();
    const user = this.database.query(`SELECT * FROM users WHERE id = ${id}`);
    this.database.disconnect();
    return user;
  }
}

// Использование с разными реализациями
const mySqlDb = new MySQLDatabase();
const userServiceWithMySQL = new UserService(mySqlDb);
const usersFromMySQL = userServiceWithMySQL.getUsers();

const mongoDb = new MongoDatabase();
const userServiceWithMongo = new UserService(mongoDb);
const usersFromMongo = userServiceWithMongo.getUsers();

В этом примере мы применяем принцип инверсии зависимостей:

1. Создали абстракцию Database
2. Реализовали конкретные классы для разных БД
3. Использовали инъекцию зависимости в UserService

Теперь UserService не зависит от конкретной реализации базы данных, а зависит от абстракции.

Применение DIP с использованием IoC-контейнера

Для более сложных проектов можно использовать контейнеры инверсии управления (IoC):

// Применение DIP с использованием простого IoC-контейнера

// Простой IoC-контейнер
class Container {
  constructor() {
    this.services = new Map();
    this.singletons = new Map();
  }
  
  // Регистрация сервиса
  register(name, definition, dependencies = []) {
    this.services.set(name, { definition, dependencies });
  }
  
  // Регистрация синглтона
  singleton(name, definition, dependencies = []) {
    this.register(name, definition, dependencies);
    this.services.get(name).singleton = true;
  }
  
  // Получение экземпляра сервиса
  get(name) {
    const service = this.services.get(name);
    
    if (!service) {
      throw new Error(`Service ${name} not found`);
    }
    
    // Возвращаем существующий экземпляр для синглтонов
    if (service.singleton && this.singletons.has(name)) {
      return this.singletons.get(name);
    }
    
    // Создаем экземпляры зависимостей
    const dependencies = service.dependencies.map(dep => this.get(dep));
    
    // Создаем экземпляр сервиса
    const instance = new service.definition(...dependencies);
    
    // Сохраняем синглтон
    if (service.singleton) {
      this.singletons.set(name, instance);
    }
    
    return instance;
  }
}

// Использование IoC-контейнера

// Интерфейс (абстрактный класс)
class Logger {
  log(message) {
    throw new Error('Method log() must be implemented');
  }
}

// Реализации
class ConsoleLogger extends Logger {
  log(message) {
    console.log(`[LOG]: ${message}`);
  }
}

class FileLogger extends Logger {
  constructor(filename) {
    super();
    this.filename = filename;
  }
  
  log(message) {
    console.log(`[FILE ${this.filename}]: ${message}`);
    // В реальном приложении здесь был бы код записи в файл
  }
}

// Сервис, который использует логгер
class UserService {
  constructor(logger) {
    this.logger = logger;
  }
  
  createUser(userData) {
    this.logger.log(`Creating user: ${JSON.stringify(userData)}`);
    // Логика создания пользователя
  }
}

// Настройка контейнера
const container = new Container();

// Регистрация сервисов
container.register('logger', ConsoleLogger);
container.register('userService', UserService, ['logger']);

// Получение сервиса с автоматически разрешенными зависимостями
const userService = container.get('userService');
userService.createUser({ name: 'John', email: 'john@example.com' });

// Переключение на другую реализацию логгера
container.register('logger', FileLogger, []);
const userServiceWithFileLogger = container.get('userService');
userServiceWithFileLogger.createUser({ name: 'Alice', email: 'alice@example.com' });

Совместное применение принципов SOLID

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

// Полный пример применения всех принципов SOLID

// 1. SRP: Каждый класс имеет только одну ответственность

// Класс для работы с данными платежа
class Payment {
  constructor(paymentData) {
    this.id = paymentData.id;
    this.amount = paymentData.amount;
    this.date = paymentData.date || new Date();
    this.status = 'new';
  }
  
  markAsProcessed() {
    this.status = 'processed';
  }
  
  markAsFailed(reason) {
    this.status = 'failed';
    this.failureReason = reason;
  }
}

// Валидатор платежей
class PaymentValidator {
  validate(payment) {
    if (!payment.amount || payment.amount <= 0) {
      throw new Error('Invalid payment amount');
    }
    
    if (!payment.id) {
      throw new Error('Payment ID is required');
    }
    
    return true;
  }
}

// 2. OCP: Система открыта для расширения, закрыта для модификации

// Абстрактный обработчик платежей
class PaymentProcessor {
  process(payment) {
    throw new Error('Method process() must be implemented');
  }
}

// Реализации для разных платежных систем
class PayPalProcessor extends PaymentProcessor {
  process(payment) {
    console.log(`Processing PayPal payment of ${payment.amount}`);
    // Интеграция с PayPal API
    payment.markAsProcessed();
    return true;
  }
}

class StripeProcessor extends PaymentProcessor {
  process(payment) {
    console.log(`Processing Stripe payment of ${payment.amount}`);
    // Интеграция с Stripe API
    payment.markAsProcessed();
    return true;
  }
}

class BitcoinProcessor extends PaymentProcessor {
  process(payment) {
    console.log(`Processing Bitcoin payment of ${payment.amount}`);
    // Интеграция с Bitcoin API
    payment.markAsProcessed();
    return true;
  }
}

// 3. LSP: Подклассы могут заменять базовые классы без нарушения функциональности

// Тестирование процессоров платежей
function testPaymentProcessor(processor) {
  const payment = new Payment({ id: 'test123', amount: 100 });
  return processor.process(payment);
}

// Все реализации PaymentProcessor должны корректно работать в этой функции
const paypalResult = testPaymentProcessor(new PayPalProcessor());
const stripeResult = testPaymentProcessor(new StripeProcessor());
const bitcoinResult = testPaymentProcessor(new BitcoinProcessor());

// 4. ISP: Разделение интерфейсов

// Интерфейс для простой оплаты
class BasicPaymentGateway {
  processPayment(payment) {
    throw new Error('Method processPayment() must be implemented');
  }
}

// Дополнительный интерфейс для возвратов
class RefundablePaymentGateway extends BasicPaymentGateway {
  refundPayment(paymentId, amount) {
    throw new Error('Method refundPayment() must be implemented');
  }
}

// Дополнительный интерфейс для подписок
class SubscriptionPaymentGateway extends BasicPaymentGateway {
  createSubscription(customerId, plan) {
    throw new Error('Method createSubscription() must be implemented');
  }
  
  cancelSubscription(subscriptionId) {
    throw new Error('Method cancelSubscription() must be implemented');
  }
}

// Реализации, использующие только нужные интерфейсы
class SimplePaymentGateway extends BasicPaymentGateway {
  constructor(processor) {
    super();
    this.processor = processor;
  }
  
  processPayment(payment) {
    return this.processor.process(payment);
  }
}

class AdvancedPaymentGateway extends RefundablePaymentGateway {
  constructor(processor) {
    super();
    this.processor = processor;
  }
  
  processPayment(payment) {
    return this.processor.process(payment);
  }
  
  refundPayment(paymentId, amount) {
    console.log(`Refunding payment ${paymentId} for amount ${amount}`);
    // Реализация возврата
    return true;
  }
}

// 5. DIP: Инверсия зависимостей

// Сервис работы с платежами зависит от абстракций, а не от конкретных реализаций
class PaymentService {
  constructor(paymentGateway, paymentValidator, logger) {
    this.paymentGateway = paymentGateway;
    this.validator = paymentValidator;
    this.logger = logger;
  }
  
  processPayment(paymentData) {
    try {
      this.logger.log(`Processing payment: ${JSON.stringify(paymentData)}`);
      
      const payment = new Payment(paymentData);
      
      // Валидация
      this.validator.validate(payment);
      
      // Обработка платежа
      const result = this.paymentGateway.processPayment(payment);
      
      this.logger.log(`Payment processed successfully: ${payment.id}`);
      return { success: true, payment };
    } catch (error) {
      this.logger.log(`Payment processing failed: ${error.message}`);
      return { success: false, error: error.message };
    }
  }
}

// Логгер (абстракция)
class Logger {
  log(message) {
    throw new Error('Method log() must be implemented');
  }
}

// Реализация логгера
class ConsoleLogger extends Logger {
  log(message) {
    console.log(`[${new Date().toISOString()}] ${message}`);
  }
}

// Использование всей системы
const logger = new ConsoleLogger();
const validator = new PaymentValidator();
const paypalProcessor = new PayPalProcessor();
const paymentGateway = new SimplePaymentGateway(paypalProcessor);

const paymentService = new PaymentService(paymentGateway, validator, logger);

// Обработка платежа
const result = paymentService.processPayment({
  id: 'order-123',
  amount: 99.99
});

console.log('Result:', result);

Преимущества принципов SOLID в JavaScript-проектах

1. Улучшенная тестируемость

Принципы SOLID, особенно SRP и DIP, значительно облегчают написание модульных тестов:

// Пример тестирования с SOLID принципами

// Мок-объект для тестирования
class MockPaymentGateway extends BasicPaymentGateway {
  constructor() {
    super();
    this.processedPayments = [];
  }
  
  processPayment(payment) {
    this.processedPayments.push(payment);
    payment.markAsProcessed();
    return true;
  }
}

// Тестирование PaymentService
function testPaymentService() {
  // Arrange
  const mockGateway = new MockPaymentGateway();
  const validator = new PaymentValidator();
  const logger = new ConsoleLogger();
  
  const paymentService = new PaymentService(mockGateway, validator, logger);
  
  // Act
  const result = paymentService.processPayment({
    id: 'test-123',
    amount: 100
  });
  
  // Assert
  console.assert(result.success === true, 'Payment should be successful');
  console.assert(mockGateway.processedPayments.length === 1, 'One payment should be processed');
  console.assert(mockGateway.processedPayments[0].status === 'processed', 'Payment status should be processed');
  
  console.log('All tests passed!');
}

testPaymentService();

2. Гибкость и масштабируемость

SOLID-принципы делают код более гибким и масштабируемым:

• SRP позволяет изменять функциональность без затрагивания несвязанного кода
• OCP обеспечивает добавление новых возможностей без изменения существующих
• LSP гарантирует, что новые подклассы работают корректно с существующим кодом
• ISP уменьшает зависимости, разделяя монолитные интерфейсы
• DIP делает высокоуровневые модули независимыми от деталей реализации

3. Повышение читаемости и поддерживаемости

SOLID-код легче:

• Понимать — каждый модуль имеет чёткую ответственность
• Поддерживать — изолированные изменения, меньше побочных эффектов
• Расширять — модульная структура с минимальными зависимостями

Применение SOLID в различных парадигмах JavaScript

SOLID в функциональном JavaScript

// Функциональный подход к SOLID

// SRP: Функции с единственной ответственностью
const validatePayment = payment => {
  if (!payment.amount || payment.amount <= 0) {
    throw new Error('Invalid payment amount');
  }
  return payment;
};

const processPayPalPayment = payment => {
  console.log(`Processing PayPal payment: ${payment.amount}`);
  return { ...payment, status: 'processed', processor: 'paypal' };
};

const processStripePayment = payment => {
  console.log(`Processing Stripe payment: ${payment.amount}`);
  return { ...payment, status: 'processed', processor: 'stripe' };
};

// OCP: Расширение через добавление функций, а не изменение существующих
const paymentProcessors = {
  paypal: processPayPalPayment,
  stripe: processStripePayment,
  // Новые процессоры можно добавить, не изменяя существующий код
  bitcoin: payment => {
    console.log(`Processing Bitcoin payment: ${payment.amount}`);
    return { ...payment, status: 'processed', processor: 'bitcoin' };
  }
};

// LSP: Функции могут быть заменены другими с той же сигнатурой
const processPayment = (payment, processor = 'paypal') => {
  const processPaymentFn = paymentProcessors[processor];
  if (!processPaymentFn) {
    throw new Error(`Payment processor ${processor} not supported`);
  }
  return processPaymentFn(payment);
};

// ISP: Функции с минимальным необходимым интерфейсом
const createPayment = ({ id, amount }) => ({ id, amount, date: new Date() });
const logPayment = payment => console.log(`Payment: ${JSON.stringify(payment)}`);
const storePayment = payment => {
  console.log(`Storing payment in database: ${payment.id}`);
  return payment;
};

// DIP: Высокоуровневые функции используют функции, переданные в качестве параметров
const processPaymentWorkflow = (
  paymentData,
  validateFn = validatePayment,
  processFn = payment => processPayment(payment, 'paypal'),
  logFn = logPayment,
  storeFn = storePayment
) => {
  try {
    const payment = createPayment(paymentData);
    const validatedPayment = validateFn(payment);
    const processedPayment = processFn(validatedPayment);
    logFn(processedPayment);
    return storeFn(processedPayment);
  } catch (error) {
    console.error('Payment workflow failed:', error.message);
    return { success: false, error: error.message };
  }
};

// Использование
const paymentResult = processPaymentWorkflow({ id: 'fn-123', amount: 100 });
console.log('Result:', paymentResult);

// Использование с другим процессором
const stripePaymentResult = processPaymentWorkflow(
  { id: 'fn-124', amount: 200 },
  validatePayment,
  payment => processPayment(payment, 'stripe')
);
console.log('Stripe Result:', stripePaymentResult);

SOLID в React-компонентах

// Пример применения SOLID в React

// SRP: Компоненты с единственной ответственностью
const PaymentForm = ({ onSubmit }) => {
  const [amount, setAmount] = useState('');
  const [cardNumber, setCardNumber] = useState('');
  
  const handleSubmit = e => {
    e.preventDefault();
    onSubmit({ amount: parseFloat(amount), cardNumber });
  };
  
  return (
    <form onSubmit={handleSubmit}>
      <input
        type="number"
        value={amount}
        onChange={e => setAmount(e.target.value)}
        placeholder="Amount"
        required
      />
      <input
        type="text"
        value={cardNumber}
        onChange={e => setCardNumber(e.target.value)}
        placeholder="Card Number"
        required
      />
      <button type="submit">Pay</button>
    </form>
  );
};

// OCP: Расширение через композицию
const PaymentMethodSelector = ({ selectedMethod, onSelect, methods }) => (
  <div className="payment-methods">
    {methods.map(method => (
      <button
        key={method.id}
        className={selectedMethod === method.id ? 'selected' : ''}
        onClick={() => onSelect(method.id)}
      >
        {method.name}
      </button>
    ))}
  </div>
);

// LSP: Компоненты могут быть заменены другими с тем же интерфейсом
const PaymentSummary = ({ payment }) => (
  <div className="payment-summary">
    <h3>Payment Summary</h3>
    <p>Amount: ${payment.amount}</p>
    <p>Status: {payment.status}</p>
    <p>Date: {payment.date.toLocaleString()}</p>
  </div>
);

const DetailedPaymentSummary = ({ payment }) => (
  <div className="payment-summary detailed">
    <h3>Detailed Payment Summary</h3>
    <p>Amount: ${payment.amount}</p>
    <p>Status: {payment.status}</p>
    <p>Date: {payment.date.toLocaleString()}</p>
    <p>Payment Method: {payment.method}</p>
    <p>Transaction ID: {payment.id}</p>
  </div>
);

// ISP: Props содержат только необходимые данные
const PaymentStatusBadge = ({ status }) => {
  const getStatusColor = () => {
    switch (status) {
      case 'processed': return 'green';
      case 'failed': return 'red';
      case 'pending': return 'orange';
      default: return 'gray';
    }
  };
  
  return (
    <span 
      className="status-badge"
      style={{ backgroundColor: getStatusColor() }}
    >
      {status}
    </span>
  );
};

// DIP: Высокоуровневые компоненты зависят от абстракций, а не деталей
const PaymentProcessor = ({ 
  paymentService, 
  onSuccess, 
  onError,
  paymentMethods = [
    { id: 'credit-card', name: 'Credit Card' },
    { id: 'paypal', name: 'PayPal' }
  ] 
}) => {
  const [selectedMethod, setSelectedMethod] = useState(paymentMethods[0].id);
  const [payment, setPayment] = useState(null);
  const [error, setError] = useState(null);
  
  const handleSubmit = async (paymentData) => {
    try {
      const result = await paymentService.processPayment({
        ...paymentData,
        method: selectedMethod
      });
      
      setPayment(result.payment);
      onSuccess && onSuccess(result.payment);
    } catch (err) {
      setError(err.message);
      onError && onError(err);
    }
  };
  
  return (
    <div className="payment-processor">
      <PaymentMethodSelector
        selectedMethod={selectedMethod}
        onSelect={setSelectedMethod}
        methods={paymentMethods}
      />
      
      <PaymentForm onSubmit={handleSubmit} />
      
      {error && <div className="error">{error}</div>}
      
      {payment && <PaymentSummary payment={payment} />}
    </div>
  );
};

// Использование
const App = () => {
  // Сервис платежей, который может быть заменен на любой другой
  const paymentService = {
    processPayment: async (paymentData) => {
      // Имитация запроса к API
      await new Promise(resolve => setTimeout(resolve, 1000));
      
      if (Math.random() > 0.8) {
        throw new Error('Payment processing failed');
      }
      
      return {
        success: true,
        payment: {
          id: `tx-${Date.now()}`,
          ...paymentData,
          status: 'processed',
          date: new Date()
        }
      };
    }
  };
  
  const handleSuccess = (payment) => {
    console.log('Payment successful:', payment);
  };
  
  const handleError = (error) => {
    console.error('Payment failed:', error);
  };
  
  return (
    <div className="app">
      <h1>Payment Page</h1>
      <PaymentProcessor
        paymentService={paymentService}
        onSuccess={handleSuccess}
        onError={handleError}
      />
    </div>
  );
};