Рефакторинг и код-ревью: как улучшить структуру кода и не сломать поведение программы
Рефакторинг и код-ревью обычно обсуждают по отдельности, хотя польза от них появляется только вместе. Рефакторинг меняет внутреннее устройство кода, не меняя того, что видит пользователь, другая программа или тест. Код-ревью — точка, где команда проверяет, что изменения действительно безопасны, а не просто «выглядят чище».
Ниже — практический разбор: как определить границы рефакторинга, чем зафиксировать поведение до изменений, что искать при просмотре чужого кода и как выстроить процесс, чтобы улучшение структуры не превращалось в многодневную переделку всего проекта.
Что такое рефакторинг и где проходят его границы
Под рефакторингом обычно понимают серию небольших преобразований, каждое из которых улучшает внутреннюю структуру кода, но не меняет его наблюдаемое поведение. Ключевое слово — «наблюдаемое»: если тот же сценарий даёт тот же результат, преобразование удалось, даже если внутри всё стало иначе.
Полезная аналогия — работа с текстом: можно переписать абзац, убрать повторы и переставить предложения, не меняя смысла. Так устроено редактирование и корректура — задача редактора сохранить авторский смысл при более ясной структуре. Похожая логика у редизайна: оформление и структура обновляются, а необходимые функции остаются. Рефакторинг — третий случай той же логики, только вместо текста или экрана — код.
Что именно считается поведением, стоит зафиксировать до начала работы. Обычно в этот список входит:
- публичный интерфейс — функции, методы, модули, эндпоинты, форматы запросов и ответов;
- формат данных — схема таблиц, структура файлов, поля событий и сообщений;
- ошибки — типы исключений, коды ответов и текст, на который опираются клиенты или тесты;
- побочные эффекты — записи в базу, отправленные события, обращения к внешним сервисам;
- логи и метрики, если на них настроены алерты или отчёты;
- ограничения по времени и ресурсам, если они заявлены как часть контракта.
Всё, чего в этом списке нет, — внутренняя кухня. Её можно менять смелее: переименовывать переменные, разбивать длинные функции, выносить общий код, менять порядок вызовов внутри модуля.
Отдельно стоит проговорить, чем рефакторинг не является. Он не заменяет исправление ошибок: если поведение неправильное, «причёсывание» кода сделает его аккуратнее, но не вернее. Он не равен переписыванию с нуля — там меняется слишком многое сразу, и проверить сохранение поведения становится почти невозможно. Он не тождествен оптимизации: ускорение часто требует изменения структур данных, и это отдельная задача со своими измерениями. И наконец, рефакторинг не должен быть спором о вкусах: если изменение нельзя объяснить через читаемость, сопровождаемость или снижение риска ошибок, это, скорее всего, вопрос стиля, который решается линтером и договорённостью команды.
Согласованное поведение: как зафиксировать состояние «до»
Главный риск рефакторинга — незаметно сломать то, что работало. Поэтому порядок действий обратный интуиции: сначала сетка безопасности, потом изменения. Хорошая сетка отвечает на вопрос «как я узнаю, что ничего не изменилось?» до того, как первая строка будет переписана.
Тесты как страховка
Самый надёжный вариант — набор тестов, который покрывает затрагиваемые сценарии и проходит до начала работы. Важно, чтобы тесты проверяли поведение, а не реализацию: тест, который ломается от переименования приватного метода, при рефакторинге превращается в помеху. Практический ориентир — тесты на публичные контракты и ключевые сценарии: успешный путь, граничные значения, обработка ошибок.
Если тестов много, но они хрупкие, полезно начать с малого: выбрать один модуль, добавить несколько тестов на его контракт и только потом трогать код. Рефакторинг «по кусочкам» с проверкой после каждого шага даёт больше уверенности, чем одна большая переделка с прогоном тестов в конце.
Если тестов нет
Отсутствие тестов — не повод отказываться от улучшений, но повод изменить темп. Рабочий подход — characterization-тесты, или «тесты-снимки»: зафиксировать текущее поведение таким, какое оно есть, включая странности. Не нужно решать, правильно ли функция работает; нужно зафиксировать, что она делает сейчас, чтобы заметить расхождение после изменений.
Технически это может быть снимок вывода (snapshot), набор входных данных с ожидаемыми результатами, снятыми с текущей версии, или интеграционный сценарий, который прогоняется на тестовой среде. Для кода, который сложно покрыть тестами (например, при работе с внешним сервисом), помогает временное логирование: включить подробный лог, прогнать типичный сценарий, сохранить результат и сравнить его после рефакторинга. Такой приём не заменяет полноценные тесты, но снижает риск грубых ошибок.
Если ни тестов, ни возможности их быстро добавить нет, разумно ограничить масштаб: улучшать изолированный участок, не менять публичные контракты и не смешивать рефакторинг с изменением функциональности в одном наборе изменений. Проверку в этом случае придётся проводить вручную — и это стоит честно заложить в план, а не надеяться на «и так должно работать».
Чек-лист код-ревью: на что смотреть в структуре кода
Ревью структуры — не поиск придирок к стилю. Его задача — заметить места, где код будет дорого сопровождать, и предложить изменения, которые не ломают поведение. Рабочий чек-лист выглядит так:
- Имена. Название отражает смысл, а не тип данных. Если для понимания переменной нужно прочитать три экрана выше, имя не помогает.
- Размер единицы. Функция или метод помещаются в голову и делают одну вещь. Ориентир — не количество строк, а число причин для изменения.
- Дублирование. Одинаковая логика в двух местах — кандидат на выделение. Но не любое совпадение: два похожих блока, которые меняются по разным причинам, лучше оставить раздельными.
- Связанность и связность. Модуль с десятью зависимостями сложно тестировать и менять. Если при правке одной функции приходится трогать пять файлов, границы проведены неудачно.
- Уровни абстракции. Функция не должна одновременно разбирать HTTP-запрос, проверять бизнес-правила и собирать SQL. Смешение уровней — частая причина трудных багов.
- Побочные эффекты. Функция, которая называется «получить», но при этом пишет в базу, обманывает читателя.
- Обработка ошибок. Понятно ли, что произойдёт при сбое? Не теряется ли исходная ошибка при обёртке? Нет ли «проглатывания» исключений?
- Границы доверия. Проверяются ли входные данные на границе системы, а не в случайных местах внутри?
- Состояние. Изменяемые общие данные, скрытые зависимости от порядка вызовов, глобальные переменные — всё это усложняет и рефакторинг, и тесты.
- Тесты в том же изменении. Если поведение не менялось, тесты должны остаться зелёными. Если менялось — это уже не рефакторинг, и в описании изменений должно быть сказано прямо.
- Читаемость диффа. Понятно ли из изменений, зачем они? Не смешаны ли переименования с правками логики?
- Обратная совместимость. Не затронуты ли публичные контракты, форматы данных, конфигурация, которая используется снаружи.
Чек-лист не нужно проходить целиком в каждом ревью — он работает как набор вопросов, которые задают, когда что-то в коде вызывает сомнение. Важнее другое: замечания должны быть привязаны к последствиям. Формулировка «здесь будет сложно добавить третий тип отчёта, потому что условие уже разрослось» полезнее, чем «мне не нравится этот if».
Как провести рефакторинг пошагово
Порядок действий ниже — не догма, а способ удержать изменения управляемыми. Он подходит и для отдельной задачи, и для постепенного улучшения большого участка кода.
- Сформулировать цель. Не «сделать красиво», а конкретно: убрать дублирование между двумя обработчиками, разделить функцию с тремя обязанностями, подготовить код к добавлению нового типа данных. Цель задаёт критерий остановки.
- Зафиксировать поведение. Прогнать существующие тесты, добавить недостающие, снять снимки вывода. Убедиться, что «до» известно и воспроизводимо.
- Определить границы. Записать, что остаётся неизменным: публичные методы, формат ответа, схема данных. Всё остальное — зона изменений.
- Работать маленькими шагами. Одно преобразование — один коммит с осмысленным сообщением. Так проще откатить конкретный шаг, не теряя остальные.
- Держать тесты зелёными. Если тест упал, следующий шаг — не «дописать ещё немного», а понять причину. Иногда причина в том, что тест был привязан к реализации, а не к поведению.
- Не смешивать с функциональностью. Отдельный набор изменений для структуры, отдельный — для новой возможности. Смешение делает ревью почти бесполезным: непонятно, какая строка сломала поведение.
- Проверить не только тесты. Прогнать сценарий вручную или на тестовой среде, посмотреть логи, оценить, не изменились ли метрики, на которые опираются алерты.
- Завершить и зафиксировать. Обновить документацию или комментарии, если они описывали старую структуру. Отметить, что осталось за рамками задачи, чтобы это не потерялось.
Отдельного упоминания заслуживает вопрос «когда остановиться». Рефакторинг легко превращается в бесконечное улучшение: всегда найдётся ещё один длинный метод. Критерий остановки задаётся в начале — например, «дублирование устранено, тесты проходят, публичный интерфейс не изменился». Всё, что за пределами критерия, оформляется как отдельная задача.
Ревью и рефакторинг внутри команды
Процесс ломается не на технике, а на коммуникации. Два фактора влияют сильнее всего: размер изменений и то, как формулируются замечания.
Размер изменений и тон комментариев
Большой дифф рецензировать бессмысленно: через двести строк внимание падает, и замечания касаются форматирования, а не структуры. Практичнее дробить работу на наборы, которые можно осмыслить за один подход, и описывать в них цель изменений. Если рефакторинг затрагивает много файлов из-за переименования, это стоит вынести в отдельный набор, где механические правки отделены от смысловых.
Тон комментариев влияет на скорость не меньше размера диффа. Полезно разделять замечания на обязательные (блокируют слияние), рекомендации (можно обсудить) и вопросы (нужно объяснение). Явная пометка «не блокирует» снимает напряжение и не даёт ревью превратиться в спор о вкусах. И обратная сторона: автору изменений стоит описывать, что именно он проверял и какие компромиссы выбрал, — это сокращает количество итераций.
Ещё один практический момент — распределённая работа. Если вы работаете в эстонской команде с коллегами из других стран или просто часть обсуждений идёт асинхронно, письменные формулировки становятся основным каналом. Здесь помогают шаблоны описания изменений: что сделано, зачем, что осталось неизменным, как проверялось. Такой шаблон полезен и для самого автора — он заставляет сформулировать критерий остановки.
Что отдать инструментам, а что оставить человеку
Часть работы по улучшению структуры хорошо автоматизируется, и это освобождает время на то, что машина делает плохо.
- Форматирование. Отступы, кавычки, переносы — задача форматтера. Договорённости о стиле, зашитые в конфиг, снимают половину замечаний на ревью.
- Линтеры. Неиспользуемые переменные, потенциально опасные конструкции, нарушения соглашений об именовании — это ловится статическим анализом до ревью.
- Проверки в конвейере. Автоматический прогон тестов и линтеров на каждый набор изменений делает состояние «зелено/красно» объективным.
- Анализ зависимостей и дублирования. Отчёты о циклических зависимостях и повторяющихся блоках помогают найти проблемные места, но решение о том, что с ними делать, остаётся за человеком.
Человеку стоит оставить то, что требует контекста: соответствует ли структура предметной области, не изменился ли смысл контракта, разумны ли компромиссы, оправдано ли усложнение ради будущей гибкости. Инструменты не знают, зачем этот код существует и какие изменения планируются.
Практический ориентир. Если сомневаетесь, стоит ли включать проверку в обязательные, задайте вопрос: даёт ли она однозначный ответ «да/нет» без обсуждения? Форматтер и линтер — да. Отчёт о «плохой архитектуре» — нет, он годится как подсказка, но не как блокирующее правило.
Чем рефакторинг отличается от переписывания кода с нуля?
При рефакторинге поведение остаётся прежним, а меняется только внутреннее устройство: имена, разбиение на функции, границы модулей. При переписывании с нуля меняется почти всё сразу, и проверить сохранение поведения гораздо сложнее — сравнить старое и новое поведение можно только по внешним контрактам, а внутренние детали уже другие. Поэтому переписывание требует отдельного плана проверки и обычно не считается рефакторингом.
Обязательно ли иметь тесты, чтобы начать рефакторинг?
Тесты сильно снижают риск, но их отсутствие — не абсолютный запрет. Если тестов нет, зафиксируйте текущее поведение другими способами: снимками вывода, интеграционным сценарием на тестовой среде, временным логированием. Затем ограничьте масштаб изменений одним изолированным участком и не трогайте публичные контракты. Чем меньше зона изменений, тем реалистичнее проверить результат вручную.
Можно ли совмещать рефакторинг и исправление ошибки в одном изменении?
Технически можно, но это усложняет ревью и откат. Если что-то сломается, будет непонятно, виновата правка логики или перестановка кода. Практичнее разделить работу: сначала небольшой рефакторинг с зелёными тестами, затем исправление ошибки отдельным набором изменений. Исключение — случаи, когда без предварительной подготовки участка исправление получается слишком запутанным; тогда стоит хотя бы описать порядок шагов в описании изменений.
Что делать, если ревьюер и автор не сходятся во мнениях о структуре?
Помогает перевести спор из плоскости вкуса в плоскость последствий: какие конкретные изменения кода станут дороже, какие риски появятся, что сломается при следующей доработке. Если аргументы симметричны, разумно принять решение по договорённости команды и зафиксировать его в общем стиле, чтобы не обсуждать одно и то же в каждом ревью. Отдельно стоит договориться, какие замечания блокируют слияние, а какие остаются рекомендациями.
Как понять, что рефакторинг пора заканчивать?
Критерий остановки задаётся до начала работы и формулируется проверяемо: например, устранено конкретное дублирование, функция разделена по названным обязанностям, тесты проходят, публичный интерфейс не изменился. Всё, что обнаружено сверх этого, оформляется как отдельная задача. Без такого критерия улучшения легко становятся бесконечными, а польза от них — всё менее заметной.
Нужно ли документировать рефакторинг, если поведение не изменилось?
Да, но не подробным описанием каждого шага. Достаточно зафиксировать, зачем изменения сделаны, что осталось неизменным и что перенесено в отдельные задачи. Если документация или комментарии описывали старую структуру, их нужно обновить — иначе следующий разработчик будет искать модули, которых больше нет. Для команды полезно также отмечать в описании изменений, как проверялся результат.