Strategy: меняем поведение без переписывания кода

Strategy: меняем поведение без переписывания кода

Скидки, сортировки, тарифы - везде есть «правило, которое меняется». Strategy позволяет менять поведение, не трогая код вокруг.

Проблема

У тебя есть расчёт скидки. Сначала была одна - студенческая. Потом добавили VIP. Потом промокод. Потом «чёрная пятница». Код превращается в:

func CalcDiscount(sum int, kind string) int {
    switch kind {
    case "student": return sum * 10 / 100
    case "vip":     return sum * 20 / 100
    case "promo":   return sum * 15 / 100
    case "friday":  return sum * 30 / 100
    // ...ещё 5 типов через месяц
    default:        return 0
    }
}
<?php
declare(strict_types=1);

function calcDiscount(int $sum, string $kind): int
{
    return match ($kind) {
        'student' => intdiv($sum * 10, 100),
        'vip'     => intdiv($sum * 20, 100),
        'promo'   => intdiv($sum * 15, 100),
        'friday'  => intdiv($sum * 30, 100),
        // ...ещё 5 типов через месяц
        default   => 0,
    };
}
def calc_discount(amount: int, kind: str) -> int:
    match kind:
        case "student":
            return amount * 10 // 100
        case "vip":
            return amount * 20 // 100
        case "promo":
            return amount * 15 // 100
        case "friday":
            return amount * 30 // 100
        # ...ещё 5 типов через месяц
        case _:
            return 0

Каждый новый тип - правка в switch/match. Это нарушает OCP (Open/Closed Principle): код открыт для модификации вместо расширения.

Решение: Strategy

Strategy - это «поведение как объект». Вместо switch по типам ты передаёшь нужную стратегию снаружи. Новый тип поведения = новая структура, старый код не трогается.

Контекст и подменяемые стратегии

Разные правила скидок

type Discount interface {
    Apply(sum int) int
}

type StudentDiscount struct{}
func (StudentDiscount) Apply(sum int) int { return sum * 10 / 100 }

type VipDiscount struct{}
func (VipDiscount) Apply(sum int) int { return sum * 20 / 100 }

type PromoDiscount struct{ percent int }
func (d PromoDiscount) Apply(sum int) int { return sum * d.percent / 100 }

func Total(sum int, d Discount) int {
    return sum - d.Apply(sum)
}

Добавить «чёрную пятницу»? Новая структура - и всё:

type BlackFridayDiscount struct{}
func (BlackFridayDiscount) Apply(sum int) int { return sum * 30 / 100 }

// вызов - ничего не менялось
total := Total(1000, BlackFridayDiscount{}) // 700
interface Discount
{
    public function apply(int $sum): int;
}

final class StudentDiscount implements Discount
{
    public function apply(int $sum): int
    {
        return intdiv($sum * 10, 100);
    }
}

final class VipDiscount implements Discount
{
    public function apply(int $sum): int
    {
        return intdiv($sum * 20, 100);
    }
}

final class PromoDiscount implements Discount
{
    public function __construct(
        private readonly int $percent,
    ) {}

    public function apply(int $sum): int
    {
        return intdiv($sum * $this->percent, 100);
    }
}

function total(int $sum, Discount $d): int
{
    return $sum - $d->apply($sum);
}

Добавить «чёрную пятницу»? Новый класс - и всё:

final class BlackFridayDiscount implements Discount
{
    public function apply(int $sum): int
    {
        return intdiv($sum * 30, 100);
    }
}

// вызов - ничего не менялось
$total = total(1000, new BlackFridayDiscount()); // 700
from dataclasses import dataclass
from typing import Protocol


class Discount(Protocol):
    def apply(self, amount: int) -> int: ...


class StudentDiscount:
    def apply(self, amount: int) -> int:
        return amount * 10 // 100


class VipDiscount:
    def apply(self, amount: int) -> int:
        return amount * 20 // 100


@dataclass(slots=True)
class PromoDiscount:
    percent: int

    def apply(self, amount: int) -> int:
        return amount * self.percent // 100


def total(amount: int, d: Discount) -> int:
    return amount - d.apply(amount)

Добавить «чёрную пятницу»? Новый класс - и всё:

class BlackFridayDiscount:
    def apply(self, amount: int) -> int:
        return amount * 30 // 100


# вызов - ничего не менялось
result = total(1000, BlackFridayDiscount())  # 700

Контракт Discount - это Protocol: класс не наследует его явно, достаточно метода apply() с той же сигнатурой. Проверяет соответствие статический анализатор (mypy, pyright), как компилятор в Go.

ℹ️ Почему это лучше switch

Новый тип скидки = новый файл. Старый код не трогаем - меньше багов (OCP привет). А ещё каждую стратегию можно тестировать изолированно.

Strategy в Go stdlib

В stdlib есть интерфейсы, которые работают именно как Strategy - и рядом такие, которые на них похожи, но решают другую задачу:

sort.Interface - стратегия сравнения для сортировки
  Len(), Less(), Swap()

http.Handler - стратегия обработки HTTP-запроса
  ServeHTTP(w, r)

io.Reader / io.Writer - источник и приёмник данных
  Read(p []byte) (n int, err error)

hash.Hash - стратегия хеширования
  Write(), Sum(), Reset()

Когда ты передаёшь http.Handler в роутер - это Strategy по смыслу: роутер не знает, что делает обработчик, и поведение подменяется целиком.

ℹ️ Не каждый интерфейс - Strategy

Соблазн назвать Strategy любую подменяемую реализацию велик, но тогда термин перестаёт что-либо значить: в Go подменяемо почти всё.

Различие в том, что именно подменяется:

  • Strategy - взаимозаменяемые способы сделать одно и то же. Разные алгоритмы сортировки, разные политики скидок, разные обработчики запроса. Выбор между ними - решение уровня логики, и его часто меняют в конфигурации;
  • абстракция ресурса или протокола - io.Reader не «стратегия чтения», а ответ на вопрос «откуда байты». Файл и сетевой сокет не альтернативные способы одного действия, это разные источники. Тот же случай - io.Writer, net.Conn, driver.Conn.

hash.Hash из списка выше - ближе к Strategy: SHA-256 и MD5 действительно взаимозаменяемые способы посчитать хеш. io.Reader - нет.

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

// http.ListenAndServe принимает любой Handler - это Strategy
http.ListenAndServe(":8080", myHandler)

Strategy vs State: в чём разница

Strategy и State структурно одинаковы - оба подменяют поведение через интерфейс. Разница в намерении:

Strategy vs State: клиент выбирает снаружи против внутреннего перехода состояний

Если поведение выбирает клиент снаружи (обычно один раз при создании, иногда подменяет позже) - это Strategy. Если объект сам переключает поведение по мере жизни - это State.

Тестируемость

Strategy делает код тестируемым - ты можешь подставить любую реализацию (это прямой результат Dependency Inversion):

func TestTotal_StudentDiscount(t *testing.T) {
    if got := Total(1000, StudentDiscount{}); got != 900 {
        t.Errorf("Total = %d, want 900", got)
    }
}

// тестовая стратегия: всегда даёт фиксированную скидку
type fixedDiscount int

func (f fixedDiscount) Apply(int) int { return int(f) }

func TestTotal_FixedDiscount(t *testing.T) {
    if got := Total(1000, fixedDiscount(500)); got != 500 {
        t.Errorf("Total = %d, want 500", got)
    }
}
<?php
declare(strict_types=1);

use PHPUnit\Framework\TestCase;

final class TotalTest extends TestCase
{
    public function testStudentDiscount(): void
    {
        self::assertSame(900, total(1000, new StudentDiscount()));
    }

    public function testFixedDiscount(): void
    {
        // тестовая стратегия: всегда даёт фиксированную скидку
        $fixed = new class implements Discount {
            public function apply(int $sum): int
            {
                return 500;
            }
        };
        self::assertSame(500, total(1000, $fixed));
    }
}
# pytest: тест - обычная функция с префиксом test_
def test_total_student_discount() -> None:
    assert total(1000, StudentDiscount()) == 900


class FixedDiscount:
    """Тестовая стратегия: всегда даёт фиксированную скидку."""

    def apply(self, amount: int) -> int:
        return 500


def test_total_fixed_discount() -> None:
    assert total(1000, FixedDiscount()) == 500

Без Strategy пришлось бы тестировать весь switch в одной функции - сложнее изолировать и дольше отлаживать.

Когда НЕ использовать

Один вариант поведения - если скидка одна и новые не планируются, switch из одного case не нужно заворачивать в интерфейс.

Алгоритм один и выбирать не из чего - если вариант поведения всегда один (не зависит ни от конфига, ни от клиента), Strategy добавляет лишний уровень абстракции.

Слишком простая логика - если «стратегия» это одна строка (return sum * percent / 100), можно передать функцию вместо интерфейса:

// функция как стратегия - легче чем интерфейс
type DiscountFunc func(sum int) int

func Total(sum int, d DiscountFunc) int {
    return sum - d(sum)
}

total := Total(1000, func(sum int) int { return sum * 10 / 100 })
// замыкание как стратегия - без интерфейса и класса
function total(int $sum, Closure $d): int
{
    return $sum - $d($sum);
}

$total = total(1000, fn (int $sum) => intdiv($sum * 10, 100));
from typing import Callable

# функция как стратегия - легче, чем протокол
DiscountFunc = Callable[[int], int]


def total(amount: int, d: DiscountFunc) -> int:
    return amount - d(amount)


result = total(1000, lambda amount: amount * 10 // 100)  # 900

⚠️ Интерфейс vs функция

В Go если интерфейс содержит один метод - подумай, нужен ли интерфейс. Часто func(...) проще и достаточно. Интерфейс оправдан когда стратегия несёт состояние или имеет несколько методов. Это же - основная идея ISP: не делай интерфейс шире, чем нужно потребителю.

Связь с другими паттернами

Factory + Strategy - фабрика создаёт нужную стратегию по конфигу
Strategy + Template - Template Method задаёт скелет, а шаги - стратегии
Strategy + DI - стратегия инжектится через конструктор

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

  • Замени switch kind на интерфейс Strategy + реализации в своём коде
  • Напиши тест, который проверяет 3 разных стратегии через один и тот же вызов
  • Найди sort.Interface в Go stdlib - как sort.Sort() использует Strategy?
  • Попробуй вариант с func вместо интерфейса - когда это удобнее?

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