Запахи кода из книги Мартина «Чистый код»

21.01.2019

Книги, ООП

Комментариев нет

Глава про «запахи кода» из книги Роберта Мартина «Чистый код» посвящена идентификации и устранению распространенных проблем в коде, которые делают его сложным для понимания, сопровождения и дальнейшего развития. «Запахи кода» — это не ошибки, а индикаторы плохих решений в коде, которые со временем могут привести к большему количеству ошибок, усложнить поддержку и ухудшить качество программного обеспечения.

Вот основные «запахи кода» и способы их устранения, о которых говорится в книге:

1. Дублирование кода

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

2. Длинные функции

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

3. Длинные классы

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

4. Избыточные комментарии

Описание: Слишком много комментариев, которые объясняют, как работает код, а не почему он так работает.
Решение: Улучшить сам код, сделав его самодокументированным, чтобы минимизировать необходимость в комментариях. Используйте комментарии для пояснения сложных решений или бизнес-логики.

5. Много аргументов у функции

Описание: Функции с большим количеством параметров сложны для понимания и использования.
Решение: Сократить количество аргументов, используя объекты для группировки параметров или применяя методы, которые вызываются внутри класса.

6. Глобальные данные

Описание: Глобальные переменные, которые могут быть изменены из любого места, приводят к неявному поведению кода.
Решение: Использовать инкапсуляцию для ограничения доступа к данным, спрятав их внутри классов и предоставив доступ через методы.

7. Длинные цепочки вызовов (чейн)

Описание: Длинные последовательности вызовов методов через точки (obj.getA().getB().getC()).
Решение: Использовать промежуточные объекты и методы для уменьшения длины цепочки и улучшения читаемости.

8. Сложные логические выражения

Описание: Условные выражения с множеством логических операторов (&&, ||) или вложенные конструкции if-else.
Решение: Разделить сложные условия на несколько простых, использовать вспомогательные методы с говорящими именами.

9. Избыточные временные переменные

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

10. Магические числа и строки

Описание: Использование в коде чисел или строк без объяснения их смысла.
Решение: Заменить магические числа и строки на константы с описательными именами.

11. Слишком много условных операторов

Описание: Избыточное использование условных операторов (if-else, switch) делает код запутанным и сложным для сопровождения.
Решение: Использовать полиморфизм, стратегические паттерны или словари (maps) для замены условных операторов.

12. Скопление данных (Data Clumps)

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

13. Ленивая или дублирующаяся классовая структура

Описание: Классы, которые делают очень мало или дублируют функциональность других классов.
Решение: Удалить или объединить такие классы с другими, чтобы избежать ненужной сложности.

14. Неиспользуемый код

Описание: Код, который больше не используется или не выполняется никогда.
Решение: Удалить неиспользуемый код, так как он засоряет проект и усложняет понимание.

15. Нарушение принципа DRY (Don’t Repeat Yourself)

Описание: Повторение одного и того же кода или логики в разных местах.
Решение: Выделить повторяющийся код в отдельные функции, классы или модули.

16. Плохая структура классов и методов (Coupling and Cohesion)

Описание: Плотная связность между классами или низкая когезия внутри классов делает код запутанным и хрупким.
Решение: Уменьшить зависимость между классами, разделить обязанности и сделать классы более независимыми.

17. Функции, нарушающие принцип единственной ответственности

Описание: Функции, выполняющие несколько разных задач.
Решение: Разделить функции на несколько более маленьких, каждая из которых выполняет одну задачу.

18. Избыточная сложность (Over-Engineering)

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

19. Отсутствие инкапсуляции

Описание: Данные и детали реализации выставлены наружу и могут изменяться извне.
Решение: Использовать инкапсуляцию, скрывая детали реализации и предоставляя доступ только через методы.

20. Сложное управление состоянием

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

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