Рефакторинг без страха: безопасные шаги
Рефакторинг - это улучшение внутренней структуры кода без изменения поведения.
Секрет: делай маленькими шагами, и будет безопасно.
Знакомая картина: открываешь проект, функция на 800 строк, тестов ноль, единственный комментарий - // не трогать, хз как оно работает. Это легаси, и оно душит: правишь одно - отваливается три, автор давно уволился, доки нет.
Плохая новость: такое есть у всех, даже в крутых командах. Хорошая: выбраться можно, и это точно не «переписать всё с нуля» - так почти всегда делать нельзя, станет только хуже.
Выбираются маленькими шагами: сначала оборачиваешь кусок тестами, чтобы поймать себя, если сломаешь. Потом аккуратно рефакторишь. Потом берёшься за следующий кусок.
Чистый код - это забота о себе будущем, который откроет этот файл через полгода. А тот, кто откроет, скорее всего ты сам.
Безопасный алгоритм рефакторинга
1. Добавь тест (или убедись, что он есть)
2. Сделай ОДНО маленькое изменение
3. Запусти тесты
4. Если зелёные - закоммить
5. Если красные - откати и разберись
6. Повтори
Каждый шаг - атомарный коммит. Если что-то пошло не так - откатываешь один коммит, а не десять. Как этот цикл выглядит целиком на живом модуле - от грязного обработчика до слоёв и тестов - показано в практическом разборе.
ℹ️ Рефактор ≠ переписывание
Переписывание = риск. Рефактор = серия маленьких улучшений. Переписывание ломает всё разом и отладка превращается в детектив. Рефакторинг ломает по одной вещи за раз.
Каталог рефакторингов
Мартин Фаулер описал десятки приёмов рефакторинга. Вот самые полезные для повседневной работы:
Extract Function (Вынос функции)
Самый частый и самый полезный приём (подробно - в уроке про маленькие функции):
// До: блок кода с комментарием
func HandleOrder(ctx context.Context, order Order) error {
// validate
if order.Total <= 0 {
return ErrInvalidTotal
}
if len(order.Items) == 0 {
return ErrNoItems
}
// process
if err := repo.Save(ctx, order); err != nil {
return err
}
notifier.Send(ctx, order)
return nil
}
// После: комментарий стал функцией
func HandleOrder(ctx context.Context, order Order) error {
if err := validateOrder(order); err != nil {
return err
}
if err := repo.Save(ctx, order); err != nil {
return err
}
notifier.Send(ctx, order)
return nil
}
func validateOrder(order Order) error {
if order.Total <= 0 { return ErrInvalidTotal }
if len(order.Items) == 0 { return ErrNoItems }
return nil
}
<?php
declare(strict_types=1);
// До: блок кода с комментарием
final class OrderHandler
{
public function handle(Order $order): void
{
// validate
if ($order->total <= 0) {
throw new DomainException('invalid total');
}
if ($order->items === []) {
throw new DomainException('no items');
}
// process
$this->repo->save($order);
$this->notifier->send($order);
}
}
<?php
declare(strict_types=1);
// После: комментарий стал методом
final class OrderHandler
{
public function handle(Order $order): void
{
$this->validateOrder($order);
$this->repo->save($order);
$this->notifier->send($order);
}
private function validateOrder(Order $order): void
{
if ($order->total <= 0) {
throw new DomainException('invalid total');
}
if ($order->items === []) {
throw new DomainException('no items');
}
}
}
# До: блок кода с комментарием
def handle_order(order: Order) -> None:
# validate
if order.total <= 0:
raise InvalidTotalError()
if not order.items:
raise NoItemsError()
# process
repo.save(order)
notifier.send(order)
# После: комментарий стал функцией
def handle_order(order: Order) -> None:
validate_order(order)
repo.save(order)
notifier.send(order)
def validate_order(order: Order) -> None:
if order.total <= 0:
raise InvalidTotalError()
if not order.items:
raise NoItemsError()
Rename (Переименование)
Самый безопасный рефакторинг - IDE делает за тебя:
// До
func proc(d []byte) error { ... }
// После: одно нажатие F2 в IDE
func processWebhookPayload(data []byte) error { ... }
<?php
declare(strict_types=1);
// До
function proc(string $d): void { /* ... */ }
// После: F2 / Shift+F6 в PhpStorm
function processWebhookPayload(string $data): void { /* ... */ }
# До
def proc(d: bytes) -> None: ...
# После: одно нажатие F2 в IDE (Rename Symbol в VS Code, Shift+F6 в PyCharm)
def process_webhook_payload(data: bytes) -> None: ...
Replace Nested Conditional with Guard Clauses
Уже знакомый паттерн из урока про ранние return:
// До: лесенка
if user != nil {
if user.Active {
return doWork(user)
}
}
return ErrBadUser
// После: guard clauses (ошибка та же, что и до)
if user == nil { return ErrBadUser }
if !user.Active { return ErrBadUser }
return doWork(user)
<?php
declare(strict_types=1);
// До: лесенка
if ($user !== null) {
if ($user->active) {
return $this->doWork($user);
}
}
throw new DomainException('bad user');
// После: guard clauses (исключение то же, что и до)
if ($user === null) {
throw new DomainException('bad user');
}
if (!$user->active) {
throw new DomainException('bad user');
}
return $this->doWork($user);
# До: лесенка
def handle(user: User | None) -> Result:
if user is not None:
if user.active:
return do_work(user)
raise BadUserError()
# После: guard clauses (исключение то же, что и до)
def handle(user: User | None) -> Result:
if user is None:
raise BadUserError()
if not user.active:
raise BadUserError()
return do_work(user)
Обрати внимание: ошибки «до» и «после» одинаковые. Разделить одну общую ошибку на две (ErrNoUser и ErrInactive) - полезно, но это уже изменение поведения: вызывающий код начнёт получать другие значения. Такую правку делают отдельным коммитом, после рефакторинга.
Здесь хорошо видно различие в подходе к ошибкам: Go возвращает sentinel-error значением, PHP и Python бросают доменное исключение. Семантика одинакова (контролируемый ранний выход), идиоматика разная.
Replace Conditional with Polymorphism
Если у тебя ветвление по типу или статусу - часто это сигнал к замене на интерфейс + dispatch: каждая ветка switch становится отдельной реализацией интерфейса, а выбор - поиском в словаре реализаций по ключу. Новый тип платежа добавляется новой реализацией, без правки процессора.
// До: switch размазан по коду, сложно добавить новый тип платежа
func (p *PaymentProcessor) Process(order Order) error {
switch order.PaymentType {
case "card":
return p.chargeCard(order)
case "paypal":
return p.chargePaypal(order)
default:
return fmt.Errorf("unknown payment type: %s", order.PaymentType)
}
}
// После: интерфейс + map реализаций
type PaymentGateway interface {
Charge(order Order) error
}
type PaymentProcessor struct {
gateways map[string]PaymentGateway
}
func (p *PaymentProcessor) Process(order Order) error {
gw, ok := p.gateways[order.PaymentType]
if !ok {
return fmt.Errorf("unknown payment type: %s", order.PaymentType)
}
return gw.Charge(order)
}
В PHP это пишется через interface + словарь реализаций (выбор по ключу с ?? throw, работает с PHP 8.0):
<?php
declare(strict_types=1);
// До: switch размазан по коду, сложно добавить новый тип платежа
final class PaymentProcessor
{
public function process(Order $order): void
{
switch ($order->paymentType) {
case 'card':
$this->chargeCard($order);
break;
case 'paypal':
$this->chargePaypal($order);
break;
case 'crypto':
$this->chargeCrypto($order);
break;
default:
throw new DomainException('unknown payment type');
}
}
}
<?php
declare(strict_types=1);
// После: интерфейс + словарь реализаций, расширяется без правки PaymentProcessor
interface PaymentGateway
{
public function charge(Order $order): void;
}
final readonly class CardGateway implements PaymentGateway { /* ... */ }
final readonly class PaypalGateway implements PaymentGateway { /* ... */ }
final readonly class CryptoGateway implements PaymentGateway { /* ... */ }
final readonly class PaymentProcessor
{
/**
* @param array<string, PaymentGateway> $gateways
*/
public function __construct(private array $gateways) {}
public function process(Order $order): void
{
$gateway = $this->gateways[$order->paymentType]
?? throw new DomainException('unknown payment type: ' . $order->paymentType);
$gateway->charge($order);
}
}
В Symfony словарь собирают через tagged services: все реализации PaymentGateway собираются автоматически (атрибуты #[AutowireIterator] или #[AutowireLocator]), без ручного перечисления. Учти: Symfony передаёт такую коллекцию как iterable или ServiceLocator, а не как array, поэтому тип параметра конструктора придётся поменять.
# До: цепочка if/elif размазана по коду
class PaymentProcessor:
def process(self, order: Order) -> None:
if order.payment_type == "card":
self._charge_card(order)
elif order.payment_type == "paypal":
self._charge_paypal(order)
else:
raise DomainError(f"unknown payment type: {order.payment_type}")
# После: Protocol + словарь реализаций
from typing import Protocol
class PaymentGateway(Protocol):
def charge(self, order: Order) -> None: ...
class PaymentProcessor:
def __init__(self, gateways: dict[str, PaymentGateway]) -> None:
self._gateways = gateways
def process(self, order: Order) -> None:
gateway = self._gateways.get(order.payment_type)
if gateway is None:
raise DomainError(f"unknown payment type: {order.payment_type}")
gateway.charge(order)
Introduce Parameter Object
Когда функция принимает слишком много аргументов:
// До: 5 параметров
func CreateReport(title string, from, to time.Time, format string, compress bool) error
// После: структура-параметр
type ReportOptions struct {
Title string
From time.Time
To time.Time
Format string
Compress bool
}
func CreateReport(opts ReportOptions) error
До: 5 параметров.
<?php
declare(strict_types=1);
function createReport(
string $title,
DateTimeImmutable $from,
DateTimeImmutable $to,
string $format,
bool $compress,
): void { /* ... */ }
После: DTO-параметр (named arguments или конструктор).
<?php
declare(strict_types=1);
final readonly class ReportOptions
{
public function __construct(
public string $title,
public DateTimeImmutable $from,
public DateTimeImmutable $to,
public string $format,
public bool $compress,
) {}
}
function createReport(ReportOptions $opts): void { /* ... */ }
from dataclasses import dataclass
from datetime import datetime
# До: 5 параметров (from - ключевое слово, format - встроенная функция,
# поэтому start/end и fmt)
def create_report(
title: str, start: datetime, end: datetime, fmt: str, compress: bool
) -> None: ...
# После: dataclass-параметр
@dataclass(frozen=True, slots=True)
class ReportOptions:
title: str
start: datetime
end: datetime
fmt: str
compress: bool
def create_report(opts: ReportOptions) -> None: ...
Replace Magic Number with Constant
// До: что значит 86400? И в каких единицах?
cache.Set(key, value, 86400*time.Second)
// После: понятно
const CacheTTL = 24 * time.Hour
cache.Set(key, value, CacheTTL)
<?php
declare(strict_types=1);
// До: что значит 86400?
$cache->setex($key, 86400, $value);
// После: понятно
final class CacheConfig
{
public const int DEFAULT_TTL_SECONDS = 86400; // 24 hours
}
$cache->setex($key, CacheConfig::DEFAULT_TTL_SECONDS, $value);
from datetime import timedelta
# До: что значит 86400?
cache.set(key, value, ex=86400)
# После: понятно (redis-py принимает timedelta в ex=)
CACHE_TTL = timedelta(hours=24)
cache.set(key, value, ex=CACHE_TTL)
Безопасный рефакторинг с тестами
Тесты - страховочная сеть рефакторинга. Без тестов рефакторинг - это «надеюсь, не сломал».
С той самой функцией на 800 строк начинают именно отсюда: не улучшать, а сначала обложить тестами то, что боишься тронуть.
Шаг Без тестов С тестами
────────────────────────── ────────────────── ──────────────────
1. Изменил код «Вроде работает» go test → зелёные
2. Нашёл баг через 2 дня «Когда сломалось?» «Тесты красные с коммита X»
3. Откатил «Что откатить?» git revert <коммит X>
Если тестов нет - напиши тест до рефакторинга:
// 1. Сначала пишем тест, который фиксирует текущее поведение
func TestCalculatePrice_LegacyBehavior(t *testing.T) {
got := calculatePrice(Order{Items: 3, Discount: 0.1})
if got != 270.0 {
t.Fatalf("calculatePrice = %v, want 270", got)
}
}
// 2. Теперь можно рефакторить calculatePrice - тест поймает регрессию
<?php
declare(strict_types=1);
use PHPUnit\Framework\TestCase;
final class CalculatePriceTest extends TestCase
{
// 1. Сначала пишем тест, который фиксирует текущее поведение
public function testLegacyBehavior(): void
{
$order = new Order(items: 3, discount: 0.1);
self::assertSame(270.0, calculatePrice($order));
}
// 2. Теперь можно рефакторить calculatePrice - тест поймает регрессию
}
# 1. Сначала пишем тест, который фиксирует текущее поведение (pytest)
def test_calculate_price_legacy_behavior() -> None:
got = calculate_price(Order(items=3, discount=0.1))
assert got == 270.0
# 2. Теперь можно рефакторить calculate_price - тест поймает регрессию
⚠️ Не рефакторь и не добавляй фичу одновременно
Рефакторинг - отдельный коммит. Новая фича - отдельный коммит. Если смешать, непонятно, что сломало тесты: рефакторинг или новый код.
IDE-поддержка рефакторинга
Современные IDE (GoLand, VS Code с gopls) умеют делать рефакторинг автоматически:
Операция GoLand VS Code
───────────────────────── ────────────── ──────────────
Rename Shift+F6 F2
Extract Function Ctrl+Alt+M Extract to func
Extract Variable Ctrl+Alt+V Extract variable
Inline Variable Ctrl+Alt+N -
Move to File F6 -
Find Usages Alt+F7 Shift+F12
Преимущество IDE-рефакторинга: она обновляет все использования, а не только текущий файл. Ручной поиск-замена легко пропускает случаи. LLM здесь IDE не заменяет: переименование отдай инструменту, который видит все ссылки, а модели поручи то, что она делает хорошо - предложить, что именно вынести и как назвать. Просить нужно с измеримым критерием, иначе получишь «сделал лучше» - как формулировать, разобрано в уроке про паттерны промптов.
Когда НЕ рефакторить
Ситуация Что делать вместо
─────────────────────────────────── ──────────────────────────
Код работает и его не трогают Оставь в покое
Нет тестов и нет времени их писать Сначала тесты, потом рефактор
Дедлайн завтра Зафиксируй TODO, вернись позже
Хочется «просто улучшить» Правило бойскаута, не перелопачивание
А комментарий // не трогать, хз как оно работает в этот список не входит. Это не запрет, это метка: сюда в первую очередь нужны тесты.
Мини-задание
- Выбери один файл и сделай 5 маленьких рефакторингов (каждый - отдельный коммит)
- Используй IDE для Rename - убедись, что все использования обновились
- Найди магическое число и замени на именованную константу
- Проверь: есть ли тест для кода, который рефакторишь? Если нет - напиши