К содержимому
← Вернуться в блог

Рефакторинг и код-ревью: как улучшить структуру кода и не сломать поведение программы

Рефакторинг и код-ревью обычно обсуждают по отдельности, хотя польза от них появляется только вместе. Рефакторинг меняет внутреннее устройство кода, не меняя того, что видит пользователь, другая программа или тест. Код-ревью — точка, где команда проверяет, что изменения действительно безопасны, а не просто «выглядят чище».

Ниже — практический разбор: как определить границы рефакторинга, чем зафиксировать поведение до изменений, что искать при просмотре чужого кода и как выстроить процесс, чтобы улучшение структуры не превращалось в многодневную переделку всего проекта.

Что такое рефакторинг и где проходят его границы

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

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

Что именно считается поведением, стоит зафиксировать до начала работы. Обычно в этот список входит:

  • публичный интерфейс — функции, методы, модули, эндпоинты, форматы запросов и ответов;
  • формат данных — схема таблиц, структура файлов, поля событий и сообщений;
  • ошибки — типы исключений, коды ответов и текст, на который опираются клиенты или тесты;
  • побочные эффекты — записи в базу, отправленные события, обращения к внешним сервисам;
  • логи и метрики, если на них настроены алерты или отчёты;
  • ограничения по времени и ресурсам, если они заявлены как часть контракта.

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

Отдельно стоит проговорить, чем рефакторинг не является. Он не заменяет исправление ошибок: если поведение неправильное, «причёсывание» кода сделает его аккуратнее, но не вернее. Он не равен переписыванию с нуля — там меняется слишком многое сразу, и проверить сохранение поведения становится почти невозможно. Он не тождествен оптимизации: ускорение часто требует изменения структур данных, и это отдельная задача со своими измерениями. И наконец, рефакторинг не должен быть спором о вкусах: если изменение нельзя объяснить через читаемость, сопровождаемость или снижение риска ошибок, это, скорее всего, вопрос стиля, который решается линтером и договорённостью команды.

Согласованное поведение: как зафиксировать состояние «до»

Главный риск рефакторинга — незаметно сломать то, что работало. Поэтому порядок действий обратный интуиции: сначала сетка безопасности, потом изменения. Хорошая сетка отвечает на вопрос «как я узнаю, что ничего не изменилось?» до того, как первая строка будет переписана.

Тесты как страховка

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

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

Если тестов нет

Отсутствие тестов — не повод отказываться от улучшений, но повод изменить темп. Рабочий подход — characterization-тесты, или «тесты-снимки»: зафиксировать текущее поведение таким, какое оно есть, включая странности. Не нужно решать, правильно ли функция работает; нужно зафиксировать, что она делает сейчас, чтобы заметить расхождение после изменений.

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

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

Чек-лист код-ревью: на что смотреть в структуре кода

Ревью структуры — не поиск придирок к стилю. Его задача — заметить места, где код будет дорого сопровождать, и предложить изменения, которые не ломают поведение. Рабочий чек-лист выглядит так:

  • Имена. Название отражает смысл, а не тип данных. Если для понимания переменной нужно прочитать три экрана выше, имя не помогает.
  • Размер единицы. Функция или метод помещаются в голову и делают одну вещь. Ориентир — не количество строк, а число причин для изменения.
  • Дублирование. Одинаковая логика в двух местах — кандидат на выделение. Но не любое совпадение: два похожих блока, которые меняются по разным причинам, лучше оставить раздельными.
  • Связанность и связность. Модуль с десятью зависимостями сложно тестировать и менять. Если при правке одной функции приходится трогать пять файлов, границы проведены неудачно.
  • Уровни абстракции. Функция не должна одновременно разбирать HTTP-запрос, проверять бизнес-правила и собирать SQL. Смешение уровней — частая причина трудных багов.
  • Побочные эффекты. Функция, которая называется «получить», но при этом пишет в базу, обманывает читателя.
  • Обработка ошибок. Понятно ли, что произойдёт при сбое? Не теряется ли исходная ошибка при обёртке? Нет ли «проглатывания» исключений?
  • Границы доверия. Проверяются ли входные данные на границе системы, а не в случайных местах внутри?
  • Состояние. Изменяемые общие данные, скрытые зависимости от порядка вызовов, глобальные переменные — всё это усложняет и рефакторинг, и тесты.
  • Тесты в том же изменении. Если поведение не менялось, тесты должны остаться зелёными. Если менялось — это уже не рефакторинг, и в описании изменений должно быть сказано прямо.
  • Читаемость диффа. Понятно ли из изменений, зачем они? Не смешаны ли переименования с правками логики?
  • Обратная совместимость. Не затронуты ли публичные контракты, форматы данных, конфигурация, которая используется снаружи.

Чек-лист не нужно проходить целиком в каждом ревью — он работает как набор вопросов, которые задают, когда что-то в коде вызывает сомнение. Важнее другое: замечания должны быть привязаны к последствиям. Формулировка «здесь будет сложно добавить третий тип отчёта, потому что условие уже разрослось» полезнее, чем «мне не нравится этот if».

Как провести рефакторинг пошагово

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

  1. Сформулировать цель. Не «сделать красиво», а конкретно: убрать дублирование между двумя обработчиками, разделить функцию с тремя обязанностями, подготовить код к добавлению нового типа данных. Цель задаёт критерий остановки.
  2. Зафиксировать поведение. Прогнать существующие тесты, добавить недостающие, снять снимки вывода. Убедиться, что «до» известно и воспроизводимо.
  3. Определить границы. Записать, что остаётся неизменным: публичные методы, формат ответа, схема данных. Всё остальное — зона изменений.
  4. Работать маленькими шагами. Одно преобразование — один коммит с осмысленным сообщением. Так проще откатить конкретный шаг, не теряя остальные.
  5. Держать тесты зелёными. Если тест упал, следующий шаг — не «дописать ещё немного», а понять причину. Иногда причина в том, что тест был привязан к реализации, а не к поведению.
  6. Не смешивать с функциональностью. Отдельный набор изменений для структуры, отдельный — для новой возможности. Смешение делает ревью почти бесполезным: непонятно, какая строка сломала поведение.
  7. Проверить не только тесты. Прогнать сценарий вручную или на тестовой среде, посмотреть логи, оценить, не изменились ли метрики, на которые опираются алерты.
  8. Завершить и зафиксировать. Обновить документацию или комментарии, если они описывали старую структуру. Отметить, что осталось за рамками задачи, чтобы это не потерялось.

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

Ревью и рефакторинг внутри команды

Процесс ломается не на технике, а на коммуникации. Два фактора влияют сильнее всего: размер изменений и то, как формулируются замечания.

Размер изменений и тон комментариев

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

Тон комментариев влияет на скорость не меньше размера диффа. Полезно разделять замечания на обязательные (блокируют слияние), рекомендации (можно обсудить) и вопросы (нужно объяснение). Явная пометка «не блокирует» снимает напряжение и не даёт ревью превратиться в спор о вкусах. И обратная сторона: автору изменений стоит описывать, что именно он проверял и какие компромиссы выбрал, — это сокращает количество итераций.

Ещё один практический момент — распределённая работа. Если вы работаете в эстонской команде с коллегами из других стран или просто часть обсуждений идёт асинхронно, письменные формулировки становятся основным каналом. Здесь помогают шаблоны описания изменений: что сделано, зачем, что осталось неизменным, как проверялось. Такой шаблон полезен и для самого автора — он заставляет сформулировать критерий остановки.

Что отдать инструментам, а что оставить человеку

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

  • Форматирование. Отступы, кавычки, переносы — задача форматтера. Договорённости о стиле, зашитые в конфиг, снимают половину замечаний на ревью.
  • Линтеры. Неиспользуемые переменные, потенциально опасные конструкции, нарушения соглашений об именовании — это ловится статическим анализом до ревью.
  • Проверки в конвейере. Автоматический прогон тестов и линтеров на каждый набор изменений делает состояние «зелено/красно» объективным.
  • Анализ зависимостей и дублирования. Отчёты о циклических зависимостях и повторяющихся блоках помогают найти проблемные места, но решение о том, что с ними делать, остаётся за человеком.

Человеку стоит оставить то, что требует контекста: соответствует ли структура предметной области, не изменился ли смысл контракта, разумны ли компромиссы, оправдано ли усложнение ради будущей гибкости. Инструменты не знают, зачем этот код существует и какие изменения планируются.

Практический ориентир. Если сомневаетесь, стоит ли включать проверку в обязательные, задайте вопрос: даёт ли она однозначный ответ «да/нет» без обсуждения? Форматтер и линтер — да. Отчёт о «плохой архитектуре» — нет, он годится как подсказка, но не как блокирующее правило.

Чем рефакторинг отличается от переписывания кода с нуля?

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

Обязательно ли иметь тесты, чтобы начать рефакторинг?

Тесты сильно снижают риск, но их отсутствие — не абсолютный запрет. Если тестов нет, зафиксируйте текущее поведение другими способами: снимками вывода, интеграционным сценарием на тестовой среде, временным логированием. Затем ограничьте масштаб изменений одним изолированным участком и не трогайте публичные контракты. Чем меньше зона изменений, тем реалистичнее проверить результат вручную.

Можно ли совмещать рефакторинг и исправление ошибки в одном изменении?

Технически можно, но это усложняет ревью и откат. Если что-то сломается, будет непонятно, виновата правка логики или перестановка кода. Практичнее разделить работу: сначала небольшой рефакторинг с зелёными тестами, затем исправление ошибки отдельным набором изменений. Исключение — случаи, когда без предварительной подготовки участка исправление получается слишком запутанным; тогда стоит хотя бы описать порядок шагов в описании изменений.

Что делать, если ревьюер и автор не сходятся во мнениях о структуре?

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

Как понять, что рефакторинг пора заканчивать?

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

Нужно ли документировать рефакторинг, если поведение не изменилось?

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