Чистый код: зачем он нужен (и почему это не занудство)
Чистый код - это не «красота ради красоты». Это скорость.
Код читают в 10 раз чаще, чем пишут. И чаще всего его читаешь ты сам... через месяц, когда уже забыл, что хотел сказать автор (спойлер: автор - ты).
Что даёт чистый код
- быстрее добавлять фичи - не нужно разбираться, что тут происходит
- проще чинить баги - видно, где логика сломалась
- легче тестировать - маленькие понятные функции покрываются за минуты
- меньше страха трогать старые места
ℹ️ Чистый код ≠ идеальный код
Цель - не сделать «идеально», а сделать понятно и безопасно для изменений. Иногда «достаточно хорошо» - это победа.
Стоимость грязного кода: технический долг
Грязный код - это технический долг (tech debt). Как и финансовый долг, он растёт с процентами:
Месяц 1: «Потом поправлю, сейчас горит»
Месяц 3: «Не трогай этот файл, он хрупкий»
Месяц 6: «Новую фичу проще написать заново, чем встроить»
Месяц 12: «Нам нужен рефакторинг на 3 спринта»
По опросу Stripe (The Developer Coefficient, 2018) разработчики тратят около 40% рабочего времени на поддержку: отладку, технический долг и разбор плохого кода вместо создания ценности. Это не абстрактная проблема - это реальные часы, за которые платит команда.
Как понять, что код «грязный»
Есть шутливая, но точная метрика:
Качество кода = количество "WTF" за минуту при ревью
А есть измеримые показатели:
Метрика Что показывает
────────────────────────── ─────────────────────────────────
Цикломатическая сложность Сколько путей выполнения в функции
Когнитивная сложность Насколько сложно человеку понять логику
Глубина вложенности Сколько уровней if/for/switch
Длина функции Слишком длинная → делает слишком много
Покрытие тестами Есть ли сеть безопасности
Цикломатическая сложность - это число 1 плюс по единице за каждый if, for, case, && и ||: столько независимых путей проходит через функцию. Когнитивная сложность дополнительно штрафует за вложенность, потому что читать вложенные условия тяжелее, чем идущие подряд. Общепринятый порог цикломатической сложности - 10: выше него функцию стоит разбивать (подробнее в уроке про маленькие функции).
Проверяют это линтеры. В Go это golangci-lint - он считает десятки метрик за секунды:
// Цикломатическая сложность 1 - идеально
func IsActive(user User) bool {
return user.Status == "active"
}
// Цикломатическая сложность 6 (1 + четыре if + один цикл) - уже стоит задуматься
func ProcessOrder(order Order) error {
if order.User == nil { return ErrNoUser }
if len(order.Items) == 0 { return ErrNoItems }
for _, item := range order.Items {
if item.Price <= 0 { return ErrInvalidPrice }
if item.Qty <= 0 { return ErrInvalidQty }
}
return nil
}
<?php
declare(strict_types=1);
// Цикломатическая сложность 1 - идеально
final readonly class UserStatus
{
public static function isActive(User $user): bool
{
return $user->status === 'active';
}
}
// Цикломатическая сложность 6 (1 + четыре if + один цикл) - уже стоит задуматься
final readonly class OrderProcessor
{
public function process(Order $order): void
{
if ($order->user === null) {
throw new DomainException('order has no user');
}
if ($order->items === []) {
throw new DomainException('order has no items');
}
foreach ($order->items as $item) {
if ($item->price <= 0) {
throw new DomainException('invalid item price');
}
if ($item->qty <= 0) {
throw new DomainException('invalid item qty');
}
}
}
}
Сложность измеряет phpmd (правило CyclomaticComplexity) или PHPStan с расширением tomasvotruba/cognitive-complexity (сам phpstan/phpstan-strict-rules сложность не считает, это строгие правила типов и сравнений). Symfony-проекты часто настраивают порог через phpmd ruleset.xml в CI - аналог golangci-lint для Go.
# Сложность считают radon (radon cc) или flake8 с плагином mccabe
# Цикломатическая сложность 1 - идеально
def is_active(user: User) -> bool:
return user.status == "active"
# Цикломатическая сложность 6 (1 + четыре if + один цикл) - уже стоит задуматься
def process_order(order: Order) -> None:
if order.user is None:
raise NoUserError
if not order.items:
raise NoItemsError
for item in order.items:
if item.price <= 0:
raise InvalidPriceError
if item.qty <= 0:
raise InvalidQtyError
Правило бойскаута
Роберт Мартин (автор «Чистого кода») предложил простое правило:
Оставь код чище, чем нашёл.
Не нужно переписывать весь файл. Достаточно каждый раз делать одно маленькое улучшение:
- переименовал непонятную переменную
- вынес дублирующийся блок в функцию
- добавил контекст к ошибке
- удалил мёртвый комментарий
Без правила бойскаута: С правилом бойскаута:
Код деградирует с каждым PR Код улучшается с каждым PR
───────────────────────────── ─────────────────────────────
Sprint 1: ████████░░ 80% Sprint 1: ████████░░ 80%
Sprint 5: ██████░░░░ 60% Sprint 5: ████████▌░ 85%
Sprint 10: ████░░░░░░ 40% Sprint 10: █████████░ 90%
⚠️ Правило бойскаута ≠ рефакторинг
Не путай с большим рефакторингом. Правило бойскаута - это микроулучшения при каждом касании файла. Если ты открыл файл для фикса бага - переименуй одну непонятную переменную заодно. Не больше.
Самая частая боль новичка
«Я боюсь что-то менять, потому что сломаю всё».
Чистый код уменьшает этот страх: изменения становятся маленькими и предсказуемыми. Но есть и второй компонент - тесты (Go, PHP, Python). Чистый код без тестов - как ремень безопасности без подушки: лучше, чем ничего, но защита неполная.
Чистый код + тесты → «Меняю уверенно, тесты покажут если сломал»
Чистый код - тесты → «Выглядит понятно, но менять всё равно страшно»
Грязный код + тесты → «Тесты зелёные, но что именно они тестируют?»
Грязный код - тесты → «Не трогай, работает»
Чистый код в Go: культура языка
Go как язык поощряет чистый код на уровне дизайна:
gofmt- единый формат, споры о стиле исключеныgo vet- статический анализ ошибок- Короткие имена для коротких скоупов, длинные - для широких
- Ошибки как значения - их видно в сигнатуре функции, а пропущенную проверку ловит линтер
errcheck(сам компилятор вызов без присваивания результата пропустит молча) - Неявные интерфейсы - тип реализует интерфейс автоматически, если у него есть нужные методы, без слова
implements. Поэтому интерфейс можно объявить там, где он нужен, и пакеты меньше связаны друг с другом
Если ты пишешь на Go и следуешь конвенциям языка - ты уже на полпути к чистому коду.
Пять принципов чистого кода
Этот трек построен вокруг пяти ключевых идей:
1. Понятные имена → урок 2
2. Маленькие функции → урок 3
3. Плоская структура → урок 4 (ранние return)
4. Явные ошибки → урок 5
5. Осмысленная структура → урок 7
Каждый принцип - маленький шаг. Вместе они дают код, который приятно читать и безопасно менять.
Мини-задание
- Найди в своём проекте файл, который страшно открывать
- Посчитай максимальную глубину вложенности (сколько уровней
if/for) - Примени правило бойскаута: сделай одно маленькое улучшение и закоммить
- Запусти
golangci-lint run --enable gocyclo,gocognit,nestif,funlen ./...и посмотри, какие функции превышают пороги сложности (по умолчанию эти линтеры выключены, поэтому их включаем явно)