Рефакторинг без страха: безопасные шаги

Рефакторинг - это улучшение внутренней структуры кода без изменения поведения.

Секрет: делай маленькими шагами, и будет безопасно.

Знакомая картина: открываешь проект, функция на 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 - убедись, что все использования обновились
  • Найди магическое число и замени на именованную константу
  • Проверь: есть ли тест для кода, который рефакторишь? Если нет - напиши

Зарегистрируйтесь бесплатно, чтобы пройти квиз, вести прогресс.