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. Если объект сам переключает поведение по мере жизни - это 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вместо интерфейса - когда это удобнее?