re:re:actable
Урок 014 минуты чтения

Что такое SOLID и как он применяется во фронтенде

На этой странице
Кратко

SOLID — пять принципов проектирования, которые помогают писать код, легкий для изменения: Single Responsibility (одна причина для изменения), Open/Closed (расширяем без изменения), Liskov Substitution (подтип заменяет базовый тип без сюрпризов), Interface Segregation (маленькие узкие интерфейсы), Dependency Inversion (зависеть от абстракций, а не от конкретных реализаций). Принципы пришли из ООП, но во фронтенде применяются к модулям, функциям, хукам и компонентам.

Вопрос

Что такое SOLID? Как объяснить каждый принцип на примере из frontend-кода?

S — Single Responsibility Principle

У модуля должна быть одна причина для изменения.

// плохо: загрузка, форматирование и отправка аналитики в одной функции
async function showOrders() { /* fetch + map + innerHTML + analytics.track */ }
 
// хорошо: каждая часть меняется независимо
const fetchOrders = (api: Api) => api.get<Order[]>("/orders");
const formatOrder = (o: Order) => `${o.id}: ${formatPrice(o.total)}`;
const renderOrders = (list: HTMLElement, rows: string[]) => { list.replaceChildren(...rows.map(toLi)); };

В React: компонент отображает UI, кастомный хук — логику, модуль API — запросы.

O — Open/Closed Principle

Код открыт для расширения и закрыт для изменения: новое поведение добавляется без правки существующего кода.

// плохо: каждый новый способ оплаты — новый case
function pay(method: string, amount: number) {
  switch (method) {
    case "card": /* ... */ break;
    case "sbp": /* ... */ break;
  }
}
 
// хорошо: новый способ — новая запись в реестре
interface PaymentMethod { pay(amount: number): Promise<void>; }
const methods: Record<string, PaymentMethod> = { card: cardPayment, sbp: sbpPayment };
 
function pay(method: string, amount: number) {
  return methods[method].pay(amount);
}

В React: компонент принимает children, render props или слоты вместо десятка булевых флагов.

L — Liskov Substitution Principle

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

interface Storage { get(key: string): string | null; set(key: string, value: string): void; }
 
class LocalStorageAdapter implements Storage { /* ... */ }
class MemoryStorage implements Storage { /* ... */ }      // для тестов и SSR
 
// нарушение: «реализация», которая бросает ошибку на set, ломает код, ожидающий Storage
class ReadOnlyStorage implements Storage {
  get(key: string) { return null; }
  set() { throw new Error("read only"); }
}

В React: <IconButton>, расширяющий <Button>, должен принимать те же onClick, disabled, type и вести себя как кнопка.

I — Interface Segregation Principle

Клиент не должен зависеть от методов, которые он не использует.

// плохо: компоненту аватара передают весь объект пользователя
function Avatar({ user }: { user: User }) { return <img src={user.avatarUrl} alt={user.name} />; }
 
// хорошо: только нужное
function Avatar({ src, alt }: { src: string; alt: string }) { return <img src={src} alt={alt} />; }

Маленькие props проще переиспользовать и тестировать, а memo реже ломается.

D — Dependency Inversion Principle

Модули верхнего уровня зависят от абстракций, а детали подставляются снаружи.

interface Logger { error(message: string, meta?: unknown): void; }
 
function createOrderService(api: Api, logger: Logger) {
  return {
    async submit(order: Order) {
      try { return await api.post("/orders", order); }
      catch (e) { logger.error("order failed", e); throw e; }
    },
  };
}
 
// в приложении — настоящие зависимости, в тестах — фейковые
const service = createOrderService(httpApi, sentryLogger);

В React DIP реализуют через props, контекст (ApiProvider) или параметры фабрик.

Что важно помнить

  • SOLID — ориентиры, а не законы: слепое следование создает лишние абстракции и overengineering.
  • SRP — про причины изменения, а не про «одну строку» или «одну функцию».
  • Во фронтенде вместо классов принципы чаще применяют к функциям, хукам, модулям и props.
  • DIP делает код тестируемым: зависимости подменяются моками без jest.mock всего модуля.
  • На собеседовании лучше привести один свой пример на каждый принцип, чем дословное определение.

Мини-шпаргалка

S — одна причина изменения. O — расширять без правки (реестр, композиция). L — подтип не ломает ожидания. I — узкие интерфейсы и props. D — зависеть от абстракций, внедрять зависимости снаружи.

Документация

Wikipedia: SOLID, Robert C. Martin: The Principles of OOD.

Дочитали до конца?
Отметьте урок — прогресс сохранится в браузере.

Поиск

Поиск по урокам