Ранние return и меньше вложенности

Ранние return и меньше вложенности

Вложенность убивает читаемость. Чем больше if внутри if, тем сложнее мозгу держать всё в голове. Каждый уровень отступа - это ещё один контекст, который нужно помнить.

Антипаттерн «лесенка»

func HandlePurchase(ctx context.Context, req PurchaseRequest) error {
    if req.User != nil {
        if req.User.Active {
            if req.Amount > 0 {
                item, err := itemRepo.Get(ctx, req.ItemID)
                if err == nil {
                    if item.InStock {
                        // наконец-то основная логика
                        return processPurchase(ctx, req.User, item)
                    }
                }
            }
        }
    }
    return errors.New("bad request")
}
public function handlePurchase(PurchaseRequest $req): Result {
    if ($req->user !== null) {
        if ($req->user->active) {
            if ($req->amount > 0) {
                $item = $this->itemRepo->find($req->itemId);
                if ($item !== null) {
                    if ($item->inStock) {
                        // наконец-то основная логика
                        return $this->processPurchase($req->user, $item);
                    }
                }
            }
        }
    }
    throw new InvalidArgumentException('bad request');
}
def handle_purchase(req: PurchaseRequest) -> Result:
    if req.user is not None:
        if req.user.active:
            if req.amount > 0:
                item = item_repo.find(req.item_id)
                if item is not None:
                    if item.in_stock:
                        # наконец-то основная логика
                        return process_purchase(req.user, item)
    raise ValueError("bad request")

Проблемы: основная логика спрятана на 5-м уровне вложенности, ошибка "bad request" не говорит, что именно плохо, и чтобы добраться до processPurchase, нужно мысленно пройти все пять условий.

Guard clauses: проверяй и выходи

Вложенная лесенка if против плоских guard clauses, happy path внизу

Guard clause - это проверка в начале функции, которая сразу возвращает ошибку при невалидном состоянии:

func HandlePurchase(ctx context.Context, req PurchaseRequest) error {
    if req.User == nil {
        return errors.New("user is required")
    }
    if !req.User.Active {
        return errors.New("user is not active")
    }
    if req.Amount <= 0 {
        return errors.New("amount must be positive")
    }
    item, err := itemRepo.Get(ctx, req.ItemID)
    if err != nil {
        return fmt.Errorf("get item %d: %w", req.ItemID, err)
    }
    if !item.InStock {
        return errors.New("item is out of stock")
    }
    return processPurchase(ctx, req.User, item)
}
public function handlePurchase(PurchaseRequest $req): Result
{
    if ($req->user === null) {
        throw new InvalidArgumentException('user is required');
    }
    if (!$req->user->active) {
        throw new DomainException('user is not active');
    }
    if ($req->amount <= 0) {
        throw new InvalidArgumentException('amount must be positive');
    }
    $item = $this->itemRepo->find($req->itemId);
    if ($item === null) {
        throw new NotFoundException("item {$req->itemId} not found");
    }
    if (!$item->inStock) {
        throw new DomainException('item is out of stock');
    }
    return $this->processPurchase($req->user, $item);
}
def handle_purchase(req: PurchaseRequest) -> Result:
    if req.user is None:
        raise ValueError("user is required")
    if not req.user.active:
        raise ValueError("user is not active")
    if req.amount <= 0:
        raise ValueError("amount must be positive")
    item = item_repo.find(req.item_id)
    if item is None:
        raise LookupError(f"item {req.item_id} not found")
    if not item.in_stock:
        raise ValueError("item is out of stock")
    return process_purchase(req.user, item)

ℹ️ Почему так проще

Читаешь сверху вниз и сразу видишь «условия входа». Не прошёл проверку - вернулись. Основная логика остаётся на нулевом уровне отступа.

Сравнение: вложенность vs ранний return

Вложенный стиль                  Ранний return
───────────────────────────────  ───────────────────────────────
if ok {                          if !ok { return err }
    if valid {                   if !valid { return err }
        if ready {               if !ready { return err }
            // работа            // работа
        }
    }
}

✗ Основная логика на уровне 3    ✓ Основная логика на уровне 0
✗ Ошибки - один общий return     ✓ Каждая ошибка - отдельная
✗ Сложно добавить проверку       ✓ Новая проверка - одна строка

Happy path - основной маршрут

Happy path - это путь выполнения при успешном сценарии. В чистом коде happy path должен идти по левому краю (минимальный отступ):

func CreateOrder(ctx context.Context, req OrderRequest) (*Order, error) {
    if err := validateOrder(req); err != nil {     // guard
        return nil, err
    }
    user, err := userRepo.Get(ctx, req.UserID)     // guard
    if err != nil {
        return nil, fmt.Errorf("get user: %w", err)
    }
    if !user.CanOrder() {                          // guard
        return nil, ErrUserCantOrder
    }

    // ← happy path идёт по левому краю
    order := NewOrder(user, req.Items)
    if err := orderRepo.Save(ctx, order); err != nil {
        return nil, fmt.Errorf("save order: %w", err)
    }
    notifier.OrderCreated(ctx, order)
    return order, nil
}
<?php
declare(strict_types=1);

final class OrderService
{
    public function __construct(
        private readonly OrderValidator $validator,
        private readonly UserRepository $users,
        private readonly OrderRepository $orders,
        private readonly OrderNotifier $notifier,
    ) {}

    public function createOrder(OrderRequest $req): Order
    {
        $this->validator->validate($req);                       // guard

        $user = $this->users->find($req->userId);               // guard
        if ($user === null) {
            throw new NotFoundException("user {$req->userId} not found");
        }
        if (!$user->canOrder()) {                               // guard
            throw new DomainException('user cannot order');
        }

        // happy path по левому краю
        $order = Order::create($user, $req->items);
        $this->orders->save($order);
        $this->notifier->orderCreated($order);

        return $order;
    }
}
def create_order(req: OrderRequest) -> Order:
    validate_order(req)                                 # guard
    user = user_repo.find(req.user_id)                  # guard
    if user is None:
        raise LookupError(f"user {req.user_id} not found")
    if not user.can_order():                            # guard
        raise UserCantOrderError

    # happy path идёт по левому краю
    order = Order.create(user, req.items)
    order_repo.save(order)
    notifier.order_created(order)
    return order

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

Идиома Go: if err != nil

В Go паттерн раннего return встроен в культуру языка (подробно об ошибках - в следующем уроке и в треке Go: errors):

func SaveReport(ctx context.Context, report Report) error {
    data, err := json.Marshal(report)
    if err != nil {
        return fmt.Errorf("marshal report: %w", err)
    }
    path := filepath.Join(reportsDir, report.ID+".json")
    if err := os.WriteFile(path, data, 0644); err != nil {
        return fmt.Errorf("write %s: %w", path, err)
    }
    if err := index.Add(ctx, report.ID, path); err != nil {
        return fmt.Errorf("index report %s: %w", report.ID, err)
    }
    return nil
}
<?php
declare(strict_types=1);

// PHP-эквивалент: typed exceptions с контекстом + previous для wrap
final class ReportService
{
    public function __construct(
        private readonly ReportIndex $index,
        private readonly string $reportsDir,
    ) {}

    public function saveReport(Report $report): void
    {
        try {
            $data = json_encode($report, JSON_THROW_ON_ERROR);
        } catch (JsonException $e) {
            throw new RuntimeException('marshal report: ' . $e->getMessage(), previous: $e);
        }

        $path = $this->reportsDir . '/' . $report->id . '.json';
        if (file_put_contents($path, $data, LOCK_EX) === false) {
            throw new RuntimeException("write {$path} failed");
        }

        try {
            $this->index->add($report->id, $path);
        } catch (Throwable $e) {
            throw new RuntimeException("index report {$report->id}", previous: $e);
        }
    }
}
# Аналог идиомы: каждый шаг - своё исключение с контекстом,
# raise ... from e сохраняет причину (как %w в Go)
def save_report(report: Report) -> None:
    try:
        data = json.dumps(asdict(report))
    except (TypeError, ValueError) as e:
        raise ReportError("marshal report") from e
    path = Path(reports_dir) / f"{report.id}.json"
    try:
        path.write_text(data)
    except OSError as e:
        raise ReportError(f"write {path}") from e
    try:
        index.add(report.id, path)
    except Exception as e:
        raise ReportError(f"index report {report.id}") from e

Это не бойлерплейт - это явная обработка каждого шага. В PHP и Python та же идея выражается отдельным try на каждый шаг с previous: / from e, как выше. Хуже - один общий try/catch вокруг всей функции: тогда контекст «на каком шаге упало» приходится восстанавливать по стек-трейсу.

⚠️ Ранний return ≠ преждевременный выход

Guard clauses - для проверки предусловий (входные данные, состояние) и случаев «делать нечего» (пустой список, фича выключена). Если же по условию выбирается одно из нескольких разных поведений, цепочка return тут не лучший инструмент: это сигнал к полиморфизму или паттерну Strategy.

Когда вложенность допустима

Не все if внутри if - зло. Вложенность нормальна, когда блоки семантически связаны:

// Транзакция: шаги внутри одного scope, rollback гарантирован через defer.
// В Go вложенность тут не нужна: её роль играет defer.
func Transfer(ctx context.Context, from, to int, amount int) error {
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    defer tx.Rollback() // после успешного Commit ничего не делает

    if err := debit(tx, from, amount); err != nil {
        return fmt.Errorf("debit: %w", err)
    }
    if err := credit(tx, to, amount); err != nil {
        return fmt.Errorf("credit: %w", err)
    }
    return tx.Commit()
}
<?php
declare(strict_types=1);

// PHP-аналог через Doctrine DBAL transactional() - функциональная вложенность оправдана:
final class TransferService
{
    public function __construct(
        private readonly Doctrine\DBAL\Connection $db,
        private readonly AccountRepository $accounts,
    ) {}

    public function transfer(int $fromId, int $toId, int $amount): void
    {
        $this->db->transactional(function () use ($fromId, $toId, $amount): void {
            try {
                $this->accounts->debit($fromId, $amount);
            } catch (Throwable $e) {
                throw new RuntimeException('debit: ' . $e->getMessage(), previous: $e);
            }

            try {
                $this->accounts->credit($toId, $amount);
            } catch (Throwable $e) {
                throw new RuntimeException('credit: ' . $e->getMessage(), previous: $e);
            }
            // commit автоматически, rollback при любом throw
        });
    }
}
# Вложенность оправдана: транзакция с commit/rollback
def transfer(from_id: int, to_id: int, amount: int) -> None:
    with db.begin() as tx:  # commit при выходе, rollback при исключении
        try:
            debit(tx, from_id, amount)
        except Exception as e:
            raise TransferError("debit") from e
        try:
            credit(tx, to_id, amount)
        except Exception as e:
            raise TransferError("credit") from e

Ключевой вопрос: связаны ли вложенные блоки семантически? Если да (транзакция, resource cleanup) - вложенность оправдана. Если нет (независимые проверки) - используй guard clauses.

Таблицы решений вместо лесенки if

Когда условий много и они независимы, вместо лесенки используй таблицу:

// Плохо: лесенка условий
func CalculateDiscount(user User, order Order) float64 {
    if user.IsPremium {
        if order.Total >= 10000 {
            return 0.15
        }
        return 0.10
    }
    if order.Total >= 10000 {
        return 0.05
    }
    return 0
}

// Лучше: таблица решений - легко расширять
type discountRule struct {
    premium  bool
    minTotal int
    discount float64
}

var discountRules = []discountRule{
    {premium: true, minTotal: 10000, discount: 0.15},
    {premium: true, minTotal: 0, discount: 0.10},
    {premium: false, minTotal: 10000, discount: 0.05},
}

func CalculateDiscount(user User, order Order) float64 {
    for _, r := range discountRules {
        if user.IsPremium == r.premium && order.Total >= r.minTotal {
            return r.discount
        }
    }
    return 0
}
<?php
declare(strict_types=1);

// Плохо: лесенка условий
final class BadDiscountCalculator
{
    public function calculate(User $user, Order $order): float
    {
        if ($user->isPremium) {
            if ($order->total >= 10000) {
                return 0.15;
            }
            return 0.10;
        }
        if ($order->total >= 10000) {
            return 0.05;
        }
        return 0.0;
    }
}

// Лучше: таблица правил - расширяется добавлением одной строки
final readonly class DiscountRule
{
    public function __construct(
        public bool $premium,
        public int $minTotal,
        public float $discount,
    ) {}
}

final class DiscountCalculator
{
    /** @var list<DiscountRule> */
    private array $rules;

    public function __construct()
    {
        $this->rules = [
            new DiscountRule(premium: true, minTotal: 10000, discount: 0.15),
            new DiscountRule(premium: true, minTotal: 0, discount: 0.10),
            new DiscountRule(premium: false, minTotal: 10000, discount: 0.05),
        ];
    }

    public function calculate(User $user, Order $order): float
    {
        foreach ($this->rules as $rule) {
            if ($user->isPremium === $rule->premium && $order->total >= $rule->minTotal) {
                return $rule->discount;
            }
        }
        return 0.0;
    }
}
# Плохо: лесенка условий
def calculate_discount(user: User, order: Order) -> float:
    if user.is_premium:
        if order.total >= 10000:
            return 0.15
        return 0.10
    if order.total >= 10000:
        return 0.05
    return 0


# Лучше: таблица решений - легко расширять
@dataclass(frozen=True)
class DiscountRule:
    premium: bool
    min_total: int
    discount: float


DISCOUNT_RULES = [
    DiscountRule(premium=True, min_total=10000, discount=0.15),
    DiscountRule(premium=True, min_total=0, discount=0.10),
    DiscountRule(premium=False, min_total=10000, discount=0.05),
]


def calculate_discount(user: User, order: Order) -> float:
    for rule in DISCOUNT_RULES:
        if user.is_premium == rule.premium and order.total >= rule.min_total:
            return rule.discount
    return 0

Две важные детали. Во-первых, условия в таблице должны совпадать с условиями в лесенке до символа: если там > 10000, а в правилах >= minTotal, то заказ ровно на 10000 получит другую скидку, и это уже не рефакторинг, а изменение поведения. Во-вторых, порядок правил важен: срабатывает первое подходящее, поэтому более специфичные правила (с большим minTotal) стоят выше.

Мини-задание

  • Найди функцию с 3+ уровнями вложенности
  • Перепиши с guard clauses - оставь happy path на нулевом уровне
  • Проверь: каждая ошибка имеет уникальное сообщение?
  • Убедись, что тесты проходят после рефакторинга

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