Main | Blog

Программирование на PHP в XXI веке: коллекции вместо циклов, функциональное мышление и отделение подготовки данных от сайд-эффектов

Programming
14.08.2025
32

Современный PHP (8.x) — это строгая типизация, readonly-свойства, enum, match, «первоклассные» коллбэки (strlen(...) в 8.1+), атрибуты и производительные JIT/OPcache. На таком фоне меняется и стиль кода: всё больше внимания на декларативные конвейеры данных, чистые функции и явные границы сайд-эффектов. Ниже — практическое руководство с примерами.

Почему коллекции лучше «ручных» циклов

Циклы (for, foreach) универсальны, но быстро обрастают условной логикой и мутациями, усложняя чтение и тестирование. Коллекции и функции высшего порядка (map/filter/reduce) дают:

  • Декларативность: читаем «что делаем», а не «как бежим по индексам».

  • Композицию: легко добавлять/переставлять шаги конвейера.

  • Меньше состояний: избегаем промежуточных переменных и счётчиков.

  • Тестируемость: каждый шаг — отдельная чистая трансформация.

Пример: фильтр, проекция и агрегат

До (императивно):

$total = 0;
foreach ($orders as $order) {
    if ($order['status'] === 'paid' && $order['amount'] > 1000) {
        $total += $order['amount'] * 0.9; // скидка
    }
}

После (чистый PHP, без фреймворков):

$paidOver1000 = array_filter($orders, fn($o) => $o['status'] === 'paid' && $o['amount'] > 1000);
$discounted   = array_map(fn($o) => $o['amount'] * 0.9, $paidOver1000);
$total        = array_reduce($discounted, fn($sum, $a) => $sum + $a, 0);

С коллекцией (например, Laravel Collection):

use Illuminate\Support\Collection;

/** @var Collection $orders */
$total = $orders
    ->where('status', 'paid')
    ->filter(fn($o) => $o['amount'] > 1000)
    ->map(fn($o) => $o['amount'] * 0.9)
    ->sum();

Такой код легче изменять: добавили ещё одну map() — и готово, без риска сломать состояние в середине цикла.

Функциональное программирование в PHP: основные приёмы

Чистые функции и неизменяемые данные

Чистая функция при одинаковом входе возвращает одинаковый выход и не имеет сайд-эффектов (никаких запросов к БД, echo, записи в файлы и т. п.).

final class Money
{
    public function __construct(
        public readonly int $amountCents,
        public readonly string $currency,
    ) {}
}

function applyDiscount(Money $price, float $rate): Money {
    return new Money((int)round($price->amountCents * (1 - $rate)), $price->currency);
}

Функции высшего порядка и «первоклассные» коллбэки

В PHP 8.1+ можно получить callable «как значение»:

$len = strlen(...); // callable
echo $len('hello'); // 5

Это удобно для композиции:

$trim   = fn(string $s): string => trim($s);
$upper  = fn(string $s): string => mb_strtoupper($s);
$format = fn(string $s): string => $upper($trim($s));

echo $format("  hi  "); // "HI"

Каррирование и частичное применение

$multiply = fn(int $a) => fn(int $b) => $a * $b;
$double   = $multiply(2);

echo $double(21); // 42

Композиция через «пайпы»

В коллекциях часто есть pipe():

$result = collect($users)
    ->filter(fn($u) => $u->active)
    ->pipe(fn($c) => ['count' => $c->count(), 'emails' => $c->pluck('email')->all()]);

Отделение подготовки данных от сайд-эффектов («Functional Core, Imperative Shell»)

Идея: вся бизнес-логика (валидация, расчёты, трансформации) — чистые функции. Сайд-эффекты (БД, API, e-mail, логирование) — на «краях» приложения, в тонкой оболочке.

Пример: импорт CSV клиентов

Шаг 1. Чистая подготовка данных

final class ClientDTO {
    public function __construct(
        public readonly string $email,
        public readonly string $name,
        public readonly ?string $phone,
    ) {}
}

function parseCsv(string $path): iterable {
    $h = fopen($path, 'rb');
    try {
        while (($row = fgetcsv($h, 0, ';')) !== false) {
            yield $row;
        }
    } finally {
        fclose($h);
    }
}

function toClientDTO(iterable $rows): iterable {
    foreach ($rows as [$email, $name, $phone]) {
        $email = mb_strtolower(trim($email));
        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            continue; // отбрасываем невалидные
        }
        yield new ClientDTO($email, trim($name), $phone ? trim($phone) : null);
    }
}

// Конвейер подготовки
$clients = toClientDTO(parseCsv('/path/clients.csv')); // iterable чистых DTO

Шаг 2. Императивная оболочка — единая точка сайд-эффектов

function persistClients(iterable $clients, PDO $pdo): int {
    $count = 0;
    $pdo->beginTransaction();
    try {
        $stmt = $pdo->prepare('INSERT INTO clients(email, name, phone) VALUES(?, ?, ?) ON CONFLICT(email) DO NOTHING');
        foreach ($clients as $c) {
            $stmt->execute([$c->email, $c->name, $c->phone]);
            $count++;
        }
        $pdo->commit();
        return $count;
    } catch (Throwable $e) {
        $pdo->rollBack();
        throw $e;
    }
}

// Все эффекты — здесь:
$pdo   = new PDO(/* ... */);
$count = persistClients($clients, $pdo);

Преимущества: чистые функции легко покрываются тестами; любые побочные действия локализованы и прозрачно контролируются (транзакции, ретраи, логирование).

Коллекции + ленивость: когда важны память и скорость

При обработке больших наборов данных используйте генераторы (yield) или ленивые коллекции (в Laravel LazyCollection), чтобы не держать всё в памяти.

function numbers(): iterable {
    for ($i = 0; $i < 10_000_000; $i++) {
        yield $i;
    }
}

$sum = 0;
foreach (numbers() as $n) {
    if ($n % 2 === 0) {
        $sum += $n;
    }
}

В Laravel:

use Illuminate\Support\LazyCollection;

$sum = LazyCollection::make(fn() => numbers())
    ->filter(fn($n) => $n % 2 === 0)
    ->reduce(fn($acc, $n) => $acc + $n, 0);

Правило: по умолчанию — декларативные коллекции; для огромных потоков — ленивые итераторы/генераторы.

Типизация, readonly, enum и Value Objects

Современный PHP поощряет устойчивые модели данных.

enum OrderStatus: string {
    case NEW = 'new';
    case PAID = 'paid';
    case SHIPPED = 'shipped';
}

final class OrderLine {
    public function __construct(
        public readonly string $sku,
        public readonly int $qty,
        public readonly int $priceCents,
    ) {}
}

final class Order {
    /** @param OrderLine[] $lines */
    public function __construct(
        public readonly string $id,
        public OrderStatus $status,
        public readonly array $lines,
    ) {}

    public function total(): int {
        return array_reduce($this->lines, fn($s, $l) => $s + $l->qty * $l->priceCents, 0);
    }
}

  • readonly защищает от случайных мутаций.

  • enum убирает «магические строки» в статусах.

  • Методы-агрегаты (total()) — чистые, легко тестируются.

Реалистичный конвейер доменной логики

Предположим, нужно рассчитать бонусы для оплаченных заказов текущего месяца и отправить уведомления.

Чистый конвейер:

/** @return iterable */
function paidOrdersForMonth(iterable $orders, DateTimeImmutable $month): iterable {
    foreach ($orders as $o) {
        if ($o->status === OrderStatus::PAID && $o->createdAt->format('Y-m') === $month->format('Y-m')) {
            yield $o;
        }
    }
}

function calculateBonusCents(Order $o): int {
    $total = $o->total();
    return (int)round($total * 0.05);
}

function bonuses(iterable $orders, DateTimeImmutable $month): iterable {
    foreach (paidOrdersForMonth($orders, $month) as $o) {
        yield [$o->id, calculateBonusCents($o)];
    }
}

Граница сайд-эффектов:

function persistBonuses(iterable $items, PDO $pdo): void {
    $stmt = $pdo->prepare('INSERT INTO bonuses(order_id, amount_cents) VALUES(?, ?)');
    $pdo->beginTransaction();
    try {
        foreach ($items as [$orderId, $amount]) {
            $stmt->execute([$orderId, $amount]);
        }
        $pdo->commit();
    } catch (Throwable $e) {
        $pdo->rollBack();
        throw $e;
    }
}

function notify(iterable $items, callable $send): void {
    foreach ($items as [$orderId, $amount]) {
        $send("Order #$orderId bonus: $amount cents");
    }
}

// Использование:
$items = bonuses($ordersFromRepo, new DateTimeImmutable('now'));
// можно разветвить поток:
persistBonuses($items, $pdo);
// если нужно уведомлять — пересоздайте генератор или предварительно материализуйте список:
$items2 = iterator_to_array(bonuses($ordersFromRepo, new DateTimeImmutable('now')));
notify($items2, $mailerSend);

Замечание: генератор «однопроходный». Если нужно использовать результат несколько раз — материализуйте (iterator_to_array) или постройте конвейер так, чтобы источники данных были повторно создаваемы.

Ошибки и неочевидные моменты

  • Микрооптимизации против ясности. Цикл может быть быстрее конкретной цепочки коллекций, но выигрыш редко критичен. Пишите понятно — профилируйте только горячие участки.

  • Скрытая мутация ввода. Не меняйте входные массивы «по месту». Возвращайте новые структуры.

  • Сайд-эффекты в середине конвейера. Любая map() с DB::insert() — запах. Разделите: сначала подготовьте данные, затем выполните эффекты.

  • Неуправляемая ленивость. Генераторы «исчезают» после прохода. Будьте внимательны к повторному использованию результата.

  • Перемешивание валидации и эффектов. Сначала собираем все ошибки валидации (чисто), затем решаем, как реагировать (лог/исключения/ответ API).

Практические приёмы для команд

  1. Внутренний гайд «только коллекции»: договоритесь использовать map/filter/reduce/pipe и избегать ручных циклов в бизнес-логике.

  2. Чистые модули: отделяйте Domain (чисто) от Infrastructure (PDO, HTTP, очереди).

  3. Типизация везде: строгие сигнатуры, enum, readonly, DTO/Value Objects.

  4. Ленивые конвейеры для больших потоков: генераторы/LazyCollection.

  5. Тесты на трансформации: один тест — одна функция/шаг конвейера; фикстуры — мелкие и явные.

  6. Транзакции и ретраи — в оболочке: эффекты — централизованно, с контролем ошибок и метрик.

  7. Обёртки-адаптеры для эффектов: вместо глобальных фасадов — явная передача зависимостей (интерфейсы + DI).

Мини-шпаргалка (cheat sheet)

  • Преобразовать:

    • foreach → array_map / ->map()

    • фильтрация → array_filter / ->filter()

    • агрегаты → array_reduce / ->sum(), ->reduce()

  • Границы эффектов:

    • БД/HTTP/файлы/лог — только в сервисах оболочки (Application/Infrastructure).

  • Производительность:

    • Много данных → генераторы/LazyCollection

    • Горячие участки → профилировать, а не гадать.

  • Типизация:

    • Всегда указывать типы аргументов/возвратов; enum для дискретных состояний; readonly для DTO.

Заключение

PHP уже давно не «про шаблоны и echo». Декларативные коллекции, функциональная композиция и строгие границы сайд-эффектов делают код короче, надёжнее и проще для эволюции. Начните с малого: перепишите один «толстый» цикл в map/filter/reduce, вынесите работу с БД в отдельный слой и добавьте тесты на чистые функции. Вскоре вы заметите, что код начал служить бизнесу, а не наоборот.

Автор Anton Amosov