Принципы SOLID простыми словами: пять правил ООП с примерами на Python

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

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

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

Статью написал:
Ваня Буявец, продюсер, основатель Checkroi
Ваня Буявец
Основатель Checkroi, продюсер, эксперт в выборе онлайн-курсов
Все 3347 статей автора Подписаться на Телеграм-канал
Одобрено экспертом:
Наташа Буявец, основатель Checkroi, эксперт по онлайн-курсам
Наташа Буявец
Основательница Checkroi, продюсер Youtube-каналов, эксперт по онлайн-курсам
Все 4011 экспертных мнений Подписаться на Телеграм-канал
Обложка: Принципы SOLID простыми словами: пять правил ООП с примерами на Python

Код, который вчера работал, сегодня ломается от одной правки в соседнем файле. Хотели поменять текст письма клиенту, а упал расчёт скидки. Знакомо каждому, кто писал программу дольше пары недель.

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

Если вы видите SOLID впервые рядом с KISS, DRY и YAGNI, сначала загляните в наш обзор принципов программирования: там все четыре правила стоят рядом, и видно, где они друг с другом спорят.

Статья рассчитана на тех, кто уже знает, что такое класс и метод. Если эти слова пока звучат туманно, начните с материала про классы и объекты в Python и с разбора четырёх принципов ООП: SOLID стоит на них сверху.

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

Что такое SOLID и откуда он взялся

Рой собирает программу из пяти аккуратных блоков

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

Буква Название Смысл в одной фразе Что ломается без него
S Single Responsibility, принцип единственной ответственности У класса одна причина меняться Правка одной функции роняет другую
O Open/Closed, принцип открытости и закрытости Новое поведение добавляем новым кодом, старый не трогаем Каждая новинка требует лезть в рабочий класс
L Liskov Substitution, принцип подстановки Лисков Наследник подставляется вместо родителя без сюрпризов Программа ведёт себя странно на «правильных» объектах
I Interface Segregation, принцип разделения интерфейсов Маленькие интерфейсы под конкретную задачу Классы реализуют методы, которые им не нужны
D Dependency Inversion, принцип инверсии зависимостей Важная логика зависит от абстракций, а детали подстраиваются Нельзя заменить базу или почту, не переписав бизнес-логику

Сами правила собрал американский программист Роберт Мартин, его в сообществе зовут Дядя Боб. В заметке о принципах объектного проектирования он пишет, что первые наброски опубликовал в марте 1995 года в группе обсуждений comp.object, а затем много раз возвращался к ним в книгах и статьях (заметка Мартина на butunclebob.com, на английском).

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

Главную мысль автор формулирует так: принципы нужны, чтобы управлять зависимостями между частями кода. Когда зависимости запутаны, код по его словам становится трудным для изменений, хрупким и непригодным для повторного использования. Звучит сухо, но за этим стоит бытовая проблема: страх трогать собственную программу.

Коротко. Программа работает и без SOLID. Принципы нужны для другого: чтобы через полгода её можно было менять без страха.

S: принцип единственной ответственности

В ранней формулировке Мартина звучит так: у класса должна быть одна и только одна причина для изменения. Через двадцать лет он уточнил, что под «причиной» имеются в виду люди. В статье 2014 года Мартин советует собирать вместе то, что меняется по одним и тем же причинам, и разделять то, что меняется по разным, а дальше прямо пишет, что причины изменений связаны с людьми: именно люди просят что-то поменять (статья Мартина о SRP, на английском).

Пример из жизни. Допустим, вы пишете скрипт для небольшого интернет-магазина, который считает выручку за день, превращает её в текст и сохраняет в файл. Первая версия обычно выглядит так:

class SalesReport:
    def __init__(self, sales):
        self.sales = sales

    def total(self):
        return sum(self.sales)

    def to_text(self):
        return f"Выручка: {self.total()} ₽"

    def save(self, path):
        with open(path, "w", encoding="utf-8") as f:
            f.write(self.to_text())

Работает. Но у этого класса три заказчика. Бухгалтер попросит считать выручку без возвратов. Руководитель захочет отчёт в таблице вместо текста. Администратор сервера скажет, что файлы теперь надо класть в облако. Все трое придут менять один и тот же класс, и каждая правка рискует задеть чужую часть.

Решение: разнести обязанности по трём маленьким классам.

class SalesStats:
    def __init__(self, sales):
        self.sales = sales

    def total(self):
        return sum(self.sales)


class TextFormatter:
    def format(self, stats):
        return f"Выручка: {stats.total()} ₽"


class FileSaver:
    def save(self, text, path):
        with open(path, "w", encoding="utf-8") as f:
            f.write(text)


stats = SalesStats([1200, 800, 500])
text = TextFormatter().format(stats)
FileSaver().save(text, "report.txt")
print(text)  # Выручка: 2500 ₽

Теперь запрос бухгалтера трогает только SalesStats, а переезд в облако касается только FileSaver. Простая проверка на нарушение: опишите класс одним предложением. Если в описании появляется союз «и» («считает выручку и сохраняет файл»), обязанностей, скорее всего, больше одной. Как такие решения складываются в целую программу, мы разбирали в статье про архитектуру приложения.

Канал основателя Checkroi Вани Буявца3 800 человек читают мой Телеграм-канал про нейросетиСобрал промпты для Claude Code и ChatGPT, разборы ИИ-инструментов и лайфхаки по продвижению бизнеса в одном местеПрисоединиться

O: принцип открытости и закрытости

Формулировка Мартина: модуль (отдельная часть программы, например класс или файл) должен быть открыт для расширения и закрыт для изменения. Проще говоря, новую возможность добавляем новым кодом, а проверенный и работающий код не переписываем.

Представьте функцию, которая считает цену со скидкой для разных покупателей:

def price_with_discount(price, customer_type):
    if customer_type == "regular":
        return price
    elif customer_type == "student":
        return price * 0.8
    elif customer_type == "vip":
        return price * 0.7

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

Решение: сделать каждую скидку отдельным классом с одинаковым методом apply.

class NoDiscount:
    def apply(self, price):
        return price


class StudentDiscount:
    def apply(self, price):
        return price * 0.8


def final_price(price, discount):
    return discount.apply(price)


class PensionerDiscount:  # новая скидка, старый код не тронут
    def apply(self, price):
        return price * 0.85


print(final_price(1000, StudentDiscount()))    # 800.0
print(final_price(1000, PensionerDiscount()))  # 850.0

Функция final_price больше не знает, какие скидки бывают. Ей важно только одно: у объекта есть метод apply. Такой приём держится на полиморфизме (способности разных объектов отвечать на один и тот же вызов по-своему), а в книгах по паттернам проектирования он называется «стратегия».

Признак нарушения легко увидеть глазами: длинная цепочка if/elif по типу объекта, которая растёт с каждой новой задачей.

CheckroiCheckroiПодборка курсов по Backend-разработке134 курса • 26 школСравните цены, школы, программу и найдите выгодные предложения по обучениюСравнить→

L: принцип подстановки Лисков

Этот принцип назван в честь Барбары Лисков, профессора MIT и лауреата премии Тьюринга. В статье, написанной вместе с Жаннет Уинг и опубликованной в ноябре 1994 года, мысль звучит так: объекты подтипа должны вести себя так же, как объекты исходного типа, насколько это может заметить любой человек или программа, которые с ними работают (статья Лисков и Уинг, PDF, на английском).

По-простому: если ваш код умеет работать с родительским классом, он должен так же спокойно работать с любым наследником. Никаких сюрпризов.

Классический пример нарушения: квадрат, унаследованный от прямоугольника. С точки зрения геометрии квадрат и правда частный случай прямоугольника. С точки зрения кода всё хуже.

class Rectangle:
    def __init__(self, width, height):
        self.width = width
        self.height = height

    def set_width(self, width):
        self.width = width

    def set_height(self, height):
        self.height = height

    def area(self):
        return self.width * self.height


class Square(Rectangle):
    def __init__(self, side):
        super().__init__(side, side)

    def set_width(self, width):
        self.width = width
        self.height = width

    def set_height(self, height):
        self.width = height
        self.height = height


def stretch(rect):
    rect.set_width(5)
    rect.set_height(10)
    return rect.area()


print(stretch(Rectangle(2, 3)))  # 50
print(stretch(Square(2)))        # 100

Функция stretch рассчитывает на прямоугольник 5 на 10 и площадь 50. Квадрат тихо подменяет ширину и возвращает 100. Ошибки нет, программа не падает, просто считает неправильно. Именно такие баги ищут дольше всего.

Решение: не наследовать квадрат от прямоугольника. Наследование (когда класс берёт поля и методы родителя) мы подробно разбирали в статье о принципах ООП. Здесь важно одно: наследника выбирают по поведению, и похожее название ничего не гарантирует. Лучше сделать для них общего родителя «фигура» с методом area, а изменение размеров оставить каждому классу своё.

Та же история с птицами: если у класса «птица» есть метод «летать», пингвин в наследники не годится. Летающих и нелетающих птиц разводят по разным типам.

В статье 2020 года Мартин признаёт, что и сам когда-то ошибочно считал этот принцип правилом про наследование. По его словам, принцип про подтипы, то есть про любые реализации одного интерфейса, в том числе при утиной типизации (статья Мартина «Solid Relevance», на английском).

Как заметить нарушение. В коде появились проверки вида isinstance(obj, Square), или наследник бросает NotImplementedError в методе родителя. Оба признака говорят, что подставлять наследника вместо родителя уже нельзя.

I: принцип разделения интерфейсов

Интерфейс (набор методов, который класс обещает реализовать) лучше делать маленьким. В статье 2020 года Мартин формулирует принцип так: держите интерфейсы небольшими, чтобы пользователи не зависели от того, что им не нужно.

Пример. В офисе есть простой принтер и многофункциональное устройство, которое печатает и сканирует. Если завести один общий интерфейс «офисная техника» с методами «печатать», «сканировать» и «отправить факс», простому принтеру придётся реализовать сканирование и факс, которых у него нет. Обычно это заканчивается заглушками, которые бросают ошибку.

Решение: два маленьких интерфейса вместо одного большого. В Python для этого есть typing.Protocol (способ описать, какие методы ждём от объекта, без обязательного наследования; появился в Python 3.8, PEP 544):

from typing import Protocol


class Printer(Protocol):
    def print_doc(self, text: str) -> None: ...


class Scanner(Protocol):
    def scan(self) -> str: ...


class SimplePrinter:
    def print_doc(self, text: str) -> None:
        print(f"Печатаю: {text}")


class OfficeMachine:
    def print_doc(self, text: str) -> None:
        print(f"МФУ печатает: {text}")

    def scan(self) -> str:
        return "скан договора"


def print_invoice(device: Printer) -> None:
    device.print_doc("счёт № 15")


print_invoice(SimplePrinter())   # Печатаю: счёт № 15
print_invoice(OfficeMachine())   # МФУ печатает: счёт № 15

Функции печати счёта нужен только принтер, и она просит только принтер. МФУ подходит сразу под оба протокола, простой принтер реализует один.

Мартин отдельно оговаривает, что острее всего проблема стоит в языках со статической типизацией вроде Java, C# или Go: там лишняя зависимость заставляет пересобирать модули. В динамических языках вроде Python эффект слабее, но, по его словам, иммунитета нет.

CheckroiCheckroiПодборка курсов по Python587 курсов • 54 школыСравните цены, школы, программу и найдите выгодные предложения по обучениюСравнить→

D: принцип инверсии зависимостей

Формулировка из статьи Мартина 2020 года: зависьте в сторону абстракций, модули верхнего уровня не должны зависеть от деталей нижнего уровня. Верхний уровень здесь означает бизнес-логику (то, ради чего программа написана: оформить заказ, посчитать зарплату). Нижний уровень означает технические детали: база данных, почта, формат файлов. Абстракция здесь означает описание того, что объект умеет делать, без подробностей, как именно: «умеет отправить сообщение» вместо «шлёт письмо через такой-то почтовый сервер».

Типичное нарушение выглядит безобидно:

class EmailSender:
    def send(self, to, text):
        print(f"Письмо для {to}: {text}")


class OrderServiceBefore:
    def __init__(self):
        self.sender = EmailSender()  # жёстко прибито к почте

    def place(self, customer):
        self.sender.send(customer, "Заказ принят")

Оформление заказа намертво связано с отправкой писем. Захотели уведомлять клиентов в Telegram, и придётся переписывать класс заказа. Захотели проверить логику заказа автотестом, и тест начнёт слать настоящие письма.

Решение: класс заказа получает «отправителя» снаружи и знает о нём только одно: у него есть метод send.

class TelegramSender:
    def send(self, to, text):
        print(f"Сообщение в Telegram для {to}: {text}")


class FakeSender:  # подделка для тестов
    def __init__(self):
        self.sent = []

    def send(self, to, text):
        self.sent.append((to, text))


class OrderService:
    def __init__(self, sender):
        self.sender = sender

    def place(self, customer):
        self.sender.send(customer, "Заказ принят")


OrderService(EmailSender()).place("anna@example.com")
OrderService(TelegramSender()).place("@anna")

fake = FakeSender()
OrderService(fake).place("test")
print(fake.sent)  # [('test', 'Заказ принят')]

Теперь заменить почту на мессенджер можно одной строкой, а в тестах подставить подделку, которая ничего никуда не шлёт. На этом приёме держится почти любая серверная разработка, поэтому в программах по backend-разработке его разбирают одним из первых.

Частая путаница: инверсия зависимостей (принцип) и внедрение зависимостей, по-английски dependency injection (приём). Принцип говорит, куда должны смотреть зависимости. Внедрение зависимостей помогает этого добиться: передать нужный объект в конструктор, как мы сделали выше.

Ваня БуявецКанал основателя Checkroi Вани БуявцаЗабирайте промпты и обучение по нейросетям в моём Телеграм-каналеБольше 3 800 человек уже применяют Claude Code, ChatGPT и другие нейросети в работе, учёбе, бизнесе и жизниПерейти в канал

Как распознать нарушение SOLID в своём коде

Лупа и чек-лист над распечаткой кода

Определения легко выучить и трудно применить. Ниже симптомы, которые новичок может заметить сам, ещё до код-ревью (проверки кода коллегой перед тем, как он попадёт в общий проект).

Симптом в коде Какой принцип нарушен Что попробовать
Класс на 500 строк, описание звучит через «и» S Разделить по заказчикам изменений
Правка текста письма ломает расчёт S Вынести форматирование в отдельный класс
Цепочка if/elif по типу растёт с каждой задачей O Отдельный класс на каждый вариант с общим методом
Проверки isinstance перед вызовом метода L Пересмотреть иерархию наследования
Наследник бросает NotImplementedError L или I Разбить родителя или интерфейс на части
Методы-заглушки, которые никто не вызывает I Несколько маленьких протоколов вместо одного
Внутри бизнес-логики создаются подключение к базе и почтовый клиент D Передавать зависимости через конструктор
Автотест не написать без настоящей базы или интернета D Подставлять подделки вместо настоящих сервисов

Хорошая привычка: перед тем как дописать очередную ветку elif или ещё один метод в большой класс, остановиться на минуту и посмотреть на эту таблицу. Рефакторинг (переделка кода без изменения его поведения) маленького класса занимает десять минут. Рефакторинг класса, в который полгода дописывали всё подряд, занимает неделю.

CheckroiCheckroiПодборка курсов по Java-разработке100 курсов • 21 школаСравните цены, школы, программу и найдите выгодные предложения по обучениюСравнить→

SOLID в Python, Java и C#: есть ли разница

Принципы одни и те же для любого объектно-ориентированного языка. Меняются только инструменты.

В Java и C# есть ключевое слово interface, и компилятор сам проверяет, что класс реализовал все обещанные методы. Поэтому примеры SOLID в учебниках часто пишут на этих языках: нарушения видны ещё до запуска. Если вас тянет в эту сторону, посмотрите курсы по Java-разработке.

В Python отдельного слова для интерфейсов нет, зато есть три способа описать ожидания:

  • Утиная типизация. «Если объект умеет крякать, считаем его уткой»: функции важно, есть ли у объекта нужный метод. От какого класса он произошёл, её не интересует. Так работают все примеры выше.
  • Абстрактные классы из модуля abc. Если унаследовать класс от ABC и пометить методы декоратором @abstractmethod, объект нельзя создать, пока наследник не переопределит все отмеченные методы (документация модуля abc).
  • Протоколы typing.Protocol. Описывают нужные методы без наследования, а ошибки ловит проверка типов вроде mypy (программа, которая ещё до запуска проверяет, что в функции передают объекты нужного вида).

Если только начинаете, хватит утиной типизации и понятных имён методов. Протоколы и абстрактные классы пригодятся, когда проект вырастет и в нём появятся коллеги. Поставить Python и редактор, в котором удобно пробовать примеры из этой статьи, поможет наша инструкция по настройке VS Code для Python.

Когда SOLID только мешает

У принципов есть заметные критики. В 2016 году разработчик Дэн Норт выступил на конференции PubConf в Лондоне с пятиминутным докладом «Why Every Element of SOLID is Wrong». На каждом слайде он разбирает один принцип и приходит к одному выводу: пишите простой код (слайды доклада, на английском).

Мартин ответил в той же статье 2020 года. Совет писать просто он называет хорошим, но добавляет, что простота требует дисциплины, а дисциплину направляют принципы. Лучший способ устроить сложный беспорядок, по его словам, сказать всем «просто пишите просто» и не дать никаких ориентиров.

Мы в редакции думаем, что правы оба. На практике SOLID вредит в трёх случаях:

  • Скрипт на один раз. Выгрузить таблицу и забыть: три класса вместо одной функции только отнимут время.
  • Маленький проект без перспектив роста. Telegram-бот на 200 строк для себя читается проще одним файлом.
  • Абстракции «про запас». Интерфейс с одной-единственной реализацией и фабрика, которая создаёт один класс, выглядят солидно, но читать такой код тяжело. Это называется оверинжиниринг, и против него есть отдельное правило YAGNI: не писать то, что пока не нужно.

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

Когда программа разрастается до десятков модулей и нескольких команд, одних SOLID уже мало: в игру вступают подходы к проектированию целых систем вроде DDD (предметно-ориентированного проектирования). SOLID при этом никуда не уходит, он работает уровнем ниже, внутри каждого модуля.

Как отвечать про SOLID на собеседовании

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

Что такое SOLID и зачем он нужен

Пять принципов проектирования классов от Роберта Мартина. Нужны, чтобы код было легко менять и тестировать: правка в одном месте не ломает другие.

Приведите пример нарушения принципа единственной ответственности

Класс заказа, который сам считает сумму, сам сохраняет себя в базу и сам шлёт письмо. У него три причины меняться.

Почему квадрат не стоит наследовать от прямоугольника

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

Чем инверсия зависимостей отличается от внедрения зависимостей

Инверсия зависимостей описывает правило: бизнес-логика зависит от абстракций. Внедрение зависимостей описывает приём: передать нужный объект снаружи, например через конструктор.

Всегда ли надо следовать SOLID

Нет. В одноразовых скриптах и маленьких проектах принципы добавляют лишнюю сложность. Сильный ответ звучит так: «применяю, когда вижу, что код будет меняться».

Главный совет: готовьте пример из своего кода. Фраза «в учебном проекте у меня был класс на 400 строк, я разнёс его на три и смог написать тесты» даёт интервьюеру повод для живого разговора, после которого заученные определения уже не нужны. Другие частые ошибки на интервью разбирали в статье о том, как пройти собеседование разработчику.

Как научиться применять SOLID на практике

Рой доволен результатом рефакторинга

Прочитать про принципы можно за вечер. Научиться видеть, где они нужны, получается только на своём коде. Вот порядок, который работает для новичка:

  1. Возьмите свой учебный проект или напишите маленький, например Telegram-бота на Python с напоминаниями.
  2. Найдите самый большой класс и опишите его одним предложением. Нашлось «и»? Разделите.
  3. Попробуйте написать тест на главную функцию. Если мешает настоящая база или отправка сообщений, передайте их через конструктор.
  4. Добавьте новую возможность: ещё один тип уведомлений или скидки. Посчитайте, сколько старых файлов пришлось открыть.
  5. Покажите код другому человеку. Свежий взгляд замечает класс-комбайн, к которому автор уже привык.

Через две-три такие итерации принципы перестают быть списком из учебника. Вы начинаете замечать лишнюю ответственность класса ещё до того, как он вырос.

Где научиться проектировать код

Разобраться в SOLID можно и самому, но за полгода самостоятельных попыток легко закрепить ошибки, которые наставник заметил бы на первом ревью. Он посмотрит ваш код и покажет, где класс берёт на себя лишнее. В хороших курсах по Python проектирование классов разбирают на домашних заданиях с ревью. В подборке ниже программы с ценами, длительностью и отзывами выпускников:

КурсШколаСтоимость со скидкойВ рассрочкуДлитель­ностьОбзор курса от Checkroi
Профессия «Python-разработчик»
Перейти на сайт курса
SkillboxSkillbox157 335 ₽5987 ₽/мес.10 месяцевОбзор курса
Fullstack-разработчик на Python
Перейти на сайт курса
НетологияНетология137 000 ₽7125 ₽/мес.21 месяцОбзор курса
ДО Профессия Python-разработчик
Перейти на сайт курса
GeekBrainsGeekBrains149 001 ₽3167 ₽/мес.10 месяцевОбзор курса
Автоматизированное тестирование на Python
Перейти на сайт курса
SkillboxSkillbox118 754 ₽4108 ₽/мес.9 месяцевОбзор курса
Профессия Python-разработчик
Перейти на сайт курса
SkillFactorySkillFactory140 040 ₽3890 ₽/мес.10 месяцевОбзор курса
Разработчик на Python
Перейти на сайт курса
НетологияНетология175 000 ₽5500 ₽/мес.6 месяцевОбзор курса
Профессия «Python-разработчик с нуля до трудоустройства»
Перейти на сайт курса
НетологияНетология81 800 ₽5500 ₽/мес.6 месяцевОбзор курса
Профессия Fullstack-разработчик на Python
Перейти на сайт курса
SkillFactorySkillFactory158 040 ₽4390 ₽/мес.16 месяцевОбзор курса
Python-разработчик + ИИ
Перейти на сайт курса
Академия СинергияАкадемия Синергия77 900 ₽3246 ₽/мес.6 месяцевОбзор курса
Python-фреймворк Django
Перейти на сайт курса
SkillboxSkillbox58 396 ₽5128 ₽/мес.3 месяцаОбзор курса

Больше программ — в полном каталоге курсов по Python

Часто задаваемые вопросы

Как расшифровывается SOLID?

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

Кто придумал принципы SOLID?

Правила собрал Роберт Мартин, первые наброски он опубликовал в 1995 году. Принцип подстановки назван в честь Барбары Лисков, строгое определение она дала вместе с Жаннет Уинг. Саму аббревиатуру из первых букв позже сложил Майкл Фэзерс.

Нужно ли знать SOLID начинающему программисту?

Да, если вы идёте в разработку на объектно-ориентированных языках: про SOLID спрашивают почти на каждом собеседовании джуна. Но учить определения наизусть мало. Важнее уметь показать нарушение и исправление на своём коде, хотя бы на учебном проекте.

Работают ли принципы SOLID в Python и JavaScript?

Работают. В этих языках нет строгих интерфейсов, как в Java или C#, поэтому принципы держатся на утиной типизации: функции важно, какие методы есть у объекта, происхождение класса роли не играет. В Python для описания ожиданий есть абстрактные классы из модуля abc и протоколы typing.Protocol.

Чем SOLID отличается от KISS, DRY и YAGNI?

KISS, DRY и YAGNI — общие правила для любого кода: делать проще, не повторяться, не писать лишнего. SOLID уже и конкретнее, он про то, как раскладывать обязанности между классами и как они зависят друг от друга. Все четыре мы подробно сравнили в статье о принципах программирования.

Нужен ли SOLID, если проект состоит из микросервисов?

Нужен. Микросервис (маленькая самостоятельная программа внутри большой системы) тоже может превратиться в клубок, если смешать в нём код, который меняется по разным причинам. Роберт Мартин прямо пишет, что микросервисы проблему единственной ответственности не решают.

Какую книгу почитать про SOLID?

Самый полный разбор от автора принципов есть в книге Роберта Мартина «Чистая архитектура», она выходила на русском. Начинать лучше с практики: возьмите свой учебный проект, найдите самый большой класс и попробуйте разделить его по обязанностям.

Читайте Checkroi первым в Google
Добавьте Checkroi в избранные источники — и наши разборы курсов и обзоры школ будут показываться выше в вашей выдаче Google.
Оставить комментарий
0 комментариев
Форма комментария

Оставьте комментарий

Напишите, что думаете. Нам важно ваше мнение!