Ревью кода: как выявить костыли и нечитаемый код

Ревью кода – это систематический процесс проверки исходного кода другими разработчиками․
Это ключевой элемент обеспечения качества программного обеспечения․

Цель ревью – выявление ошибок, улучшение читаемости, распространение знаний и предотвращение появления “костылей”․
Качественное ревью снижает риск возникновения багов в будущем и упрощает поддержку проекта․

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

Типичные признаки “костылей” в коде

“Костыли” в коде – это временные, часто неэлегантные решения, призванные обойти проблему, а не решить её фундаментально․ Они могут возникнуть из-за спешки, недостатка знаний или просто лени․ Важно уметь их распознавать на ревью, чтобы предотвратить накопление технического долга․

Вот некоторые распространенные признаки “костылей”:

• Чрезмерное использование try-catch блоков для подавления исключений без их обработки․ Это может скрыть реальные проблемы и затруднить отладку․
• Игнорирование предупреждений компилятора․ Предупреждения часто указывают на потенциальные ошибки или неоптимальный код;
• Большие, монолитные функции, выполняющие множество несвязанных задач․ Такие функции сложно понимать, тестировать и поддерживать․
• Использование глобальных переменных без необходимости․ Глобальные переменные могут привести к непредсказуемым побочным эффектам и затруднить рефакторинг․
• Повторяющийся код, скопированный и вставленный в разных местах․ Это увеличивает вероятность ошибок и усложняет внесение изменений․
• Сложные и запутанные логические выражения, которые трудно понять с первого взгляда․
• Неожиданные побочные эффекты функций, которые изменяют состояние программы неявно․
• Использование комментариев для объяснения сложного и запутанного кода вместо его рефакторинга․ Комментарии должны объяснять почему код написан так, а не что он делает․
• Отсутствие тестов или наличие только поверхностных тестов, которые не покрывают все возможные сценарии․

Обнаружение “костылей” требует внимательности и опыта․ Важно задавать вопросы, разбираться в логике кода и не бояться предлагать альтернативные решения․ Помните, что цель ревью – не найти ошибки, а помочь разработчику написать лучший код․

Важно помнить: “костыль” – это не всегда плохо․ В некоторых случаях, временное решение может быть оправдано, но оно должно быть четко обозначено и запланировано к рефакторингу в будущем․

2․1․ Использование магических чисел и строк

Магические числа и строки – это числовые или строковые литералы, используемые непосредственно в коде без объяснения их значения․ Они делают код трудным для понимания, поддержки и изменения․ Например, использование числа 42 без указания, что это означает, является магическим числом․

Почему это плохо?

• Снижение читаемости: Другим разработчикам (и вам в будущем) будет сложно понять, что означает это число или строка․
• Усложнение поддержки: Если значение должно быть изменено, придется искать все экземпляры этого числа или строки в коде, что может быть трудоемким и подвержено ошибкам․
• Риск ошибок: Легко ошибиться при копировании и вставке магических чисел или строк, что может привести к непредсказуемым результатам․
• Нарушение принципа DRY (Don’t Repeat Yourself): Магические числа и строки часто дублируются в разных местах кода․

Как это исправить?

1. Определите константы: Замените магические числа и строки именованными константами с понятными именами․ Например, вместо if (status == 1) используйте if (status == STATUS_ACTIVE), где STATUS_ACTIVE – это константа, определенная где-то в коде․
2. Используйте перечисления (enums): Для набора связанных значений используйте перечисления․ Это улучшает читаемость и безопасность кода․
3. Выносите значения в конфигурационные файлы: Если значение может меняться в зависимости от окружения, вынесите его в конфигурационный файл․

Пример:

// Плохо

if (user․age > 18) { ․․․ }

// Хорошо

const int LEGAL_AGE = 18;

if (user․age > LEGAL_AGE) { ․․․ }

2․2․ Дублирование кода

Дублирование кода (code duplication) – это наличие идентичных или очень похожих фрагментов кода в разных местах программы․ Это один из самых распространенных “костылей”, который значительно ухудшает качество кода и усложняет его поддержку․

Почему дублирование кода – это плохо?

• Усложнение поддержки: Если нужно изменить логику, реализованную в дублированном коде, придется вносить изменения во всех его копиях․ Это увеличивает вероятность ошибок и требует больше времени․
• Увеличение размера кода: Дублирование кода увеличивает размер кодовой базы, что затрудняет ее понимание и навигацию․
• Риск несогласованности: Если изменения внесены не во все копии кода, это может привести к несогласованности и непредсказуемому поведению программы․
• Нарушение принципа DRY (Don’t Repeat Yourself): Дублирование кода является прямым нарушением этого принципа․

Как выявлять дублирование кода?

1. Визуальный осмотр: Внимательно просматривайте код, обращая внимание на повторяющиеся фрагменты․
2. Использование инструментов статического анализа: Существуют инструменты, которые автоматически выявляют дублирование кода (например, SonarQube, PMD)․
3. Поиск по кодовой базе: Используйте функцию поиска в вашей IDE, чтобы найти все экземпляры определенного фрагмента кода․

Как устранять дублирование кода?

• Вынесение общего кода в функции: Если повторяющийся код выполняет одну и ту же задачу, вынесите его в отдельную функцию․
• Создание классов и методов: Используйте объектно-ориентированное программирование для создания классов и методов, которые инкапсулируют общую логику․
• Использование шаблонов проектирования: Шаблоны проектирования могут помочь вам избежать дублирования кода и сделать код более гибким и расширяемым․

Пример:

// Плохо

function calculateAreaRectangle(width, height) { return width * height; }

function calculateAreaSquare(side) { return side * side; }

// Хорошо

function calculateArea(width, height) { return width * height; }

// Для квадрата: calculateArea(side, side);

2․3․ Чрезмерно сложные условия и вложенность

Чрезмерно сложные условия и глубокая вложенность – это верный признак “костылей” и плохого стиля программирования․ Они делают код трудным для понимания, отладки и поддержки․ Такие конструкции часто возникают из-за попыток обойти сложные проблемы, не решив их фундаментально․

Почему сложные условия и вложенность – это плохо?

• Снижение читаемости: Чем сложнее условие, тем труднее понять, что делает код․ Глубокая вложенность усугубляет эту проблему․
• Увеличение вероятности ошибок: Сложные условия сложнее тестировать, что увеличивает вероятность ошибок․
• Усложнение рефакторинга: Изменение сложного кода может привести к непредвиденным последствиям․
• Нарушение принципа единственной ответственности: Сложные условия часто указывают на то, что функция или класс выполняет слишком много задач․

Как выявлять сложные условия и вложенность?

1. Визуальный осмотр: Обращайте внимание на длинные строки с множеством логических операторов (&&, ||, !)․
2. Использование инструментов статического анализа: Некоторые инструменты могут выявлять сложные условия и глубокую вложенность․
3. Цикломатическая сложность: Измерьте цикломатическую сложность функции или метода․ Высокое значение указывает на сложный код․

Как упростить сложные условия и вложенность?

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

Пример:

// Плохо

if (a > 0 && b < 10 || c == 5 && d != 2) { // ․․․ }

// Хорошо

const condition1 = a > 0 && b < 10;

const condition2 = c == 5 && d != 2;

if (condition1 || condition2) { // ․․․ }

Как выявлять нечитаемый код

Нечитаемый код – это код, который трудно понять, изменить и поддерживать․ Он может быть вызван множеством факторов, включая плохое форматирование, неинформативные имена, чрезмерную сложность и отсутствие комментариев․ Выявление такого кода – важная часть ревью․

Первый шаг – это общее впечатление․ Если вам трудно понять, что делает код, не тратя много времени, это уже тревожный сигнал․ Попробуйте прочитать код, как если бы вы видели его впервые․ Задайте себе вопросы: "Что делает этот код?", "Как он работает?", "Почему он написан именно так?"․

Обратите внимание на следующие признаки нечитаемого кода:

• Длинные функции и методы: Функции, которые занимают больше нескольких десятков строк, обычно трудно понять․
• Большое количество параметров: Функции с большим количеством параметров сложнее использовать и тестировать․
• Глобальные переменные: Глобальные переменные могут привести к непредсказуемым побочным эффектам․
• Отсутствие комментариев: Комментарии помогают понять, что делает код и почему он написан именно так․
• Непоследовательный стиль кодирования: Непоследовательный стиль кодирования затрудняет чтение и понимание кода․

Используйте инструменты статического анализа: Многие инструменты могут автоматически выявлять нечитаемый код, например, длинные функции, сложные условия и дублирование кода․ Они могут предоставить ценную информацию и помочь вам сосредоточиться на наиболее проблемных участках кода․

Практикуйте "парное программирование" или "ревью в паре": Обсуждение кода с другим разработчиком может помочь выявить проблемы, которые вы могли пропустить самостоятельно․ Другой взгляд может быть очень полезным․

Не бойтесь задавать вопросы: Если вы не понимаете, что делает код, не стесняйтесь задавать вопросы автору․ Лучше потратить немного времени на выяснение, чем допустить ошибку․

Помните: Цель ревью кода – не найти ошибки, а улучшить качество кода․ Будьте конструктивны и предлагайте решения, а не просто критикуйте․