К содержимому
Войти

PHP Road Map

🔁 Замыкания, callable и генераторы

Замыкания в PHP встречаются на каждом шагу: колбэк для array_map, обработчик события, middleware, маршрут в Laravel. Генераторы реже бросаются в глаза, но именно они позволяют пройти CSV на миллион строк или выгрузку из базы, не упираясь в memory_limit. На собеседовании по этой теме дают код с use и спрашивают, что он выведет, а потом просят объяснить, зачем нужен yield

🧠 Как это устроено

Анонимная функция — это объект Closure

function () { ... } без имени создаёт объект класса Closure. Его можно положить в переменную, передать аргументом и вернуть из функции. В отличие от JavaScript, внешние переменные внутрь сами не попадают: тело анонимной функции видит только свои параметры и то, что перечислено в use

use ($x) копирует значение в момент создания замыкания, а не в момент вызова. Если после этого переменную снаружи поменять, замыкание этого не заметит. use (&$x) привязывает ссылку: замыкание видит текущее значение и может его менять

С объектами есть нюанс. Переменная с объектом хранит идентификатор объекта, и use ($cfg) копирует именно его. Поэтому изменение свойства $cfg->limit снаружи замыкание увидит, а присваивание $cfg = new stdClass() уже нет: замыкание держит старый объект. Подробнее о том, как передаются значения и объекты, — на странице про массивы, ссылки и copy-on-write

Стрелочные функции

fn($x) => $x * $rate появилась в PHP 7.4. Тело — одно выражение, return не пишется. Главное отличие от function в захвате: стрелочная функция сама захватывает по значению все внешние переменные, которые встретились в выражении. Писать use не нужно, а захватить по ссылке нельзя совсем

Отсюда правило выбора. Нужен короткий колбэк, который читает внешние переменные, — бери fn. Нужно изменить внешнюю переменную или написать несколько операторов — function с use

$this, static и привязка

Замыкание из метода автоматически получает $this этого объекта. Это касается и function, и fn. Удобно, но есть цена: пока жив колбэк, жив и объект, на который он ссылается. В обычном PHP-FPM запрос всё равно умрёт целиком, а в долгоживущем воркере такой колбэк в статическом реестре держит объект до перезапуска процесса. Как устроены воркеры, разобрано в модуле про то, как PHP выполняет код

static function и static fn запрещают привязку $this. Внутри такого замыкания $this недоступен, а попытка привязать объект позже выдаёт предупреждение и возвращает null. Писать static стоит в колбэках, которым объект не нужен: это явно говорит, что ссылки на $this нет

Привязку можно поменять руками:

  • Closure::bind($fn, $obj, Foo::class) и $fn->bindTo($obj, Foo::class) возвращают новое замыкание с другим $this и другой областью видимости. Второй аргумент задаёт класс, чьи private и protected члены будут доступны внутри
  • $fn->call($obj) привязывает и сразу вызывает

Через bind гидраторы и тестовые помощники читают закрытые свойства, а Laravel так реализует макросы. В прикладном коде это обычно обход инкапсуляции без причины

Какие бывают callable

callable — тип для всего, что можно вызвать. Форм несколько, и на легаси-коде встретятся все:

ФормаПримерЧто важно
Строка с именем функции'strlen'IDE и статический анализ не видят, что это вызов
Строка со статическим методом'Str::up'То же самое
Массив[Str::class, 'up'], [$obj, 'low']Видимость метода проверяется в момент вызова
Объект Closurefunction () {}, fn() => 1Обычное замыкание
Closure::fromCallable('strlen')Превращает любую форму в ClosureСтарый способ, до 8.1
First-class callablestrlen(...), $this->save(...), Str::up(...)С PHP 8.1, то же, что fromCallable

Синтаксис strlen(...) с PHP 8.1 вытеснил строки и массивы. Он сразу проверяет, что функция существует, его понимают PHPStan и IDE, и он запоминает область видимости в месте создания. $this->secret(...) внутри класса даёт рабочее замыкание на приватный метод, а массив [$this, 'secret'], вызванный снаружи класса, упадёт на проверке видимости. Остальное, что пришло в 8.1 и позже, — на странице «Современный PHP: от 8.1 до 8.6»

Генераторы и yield

Функция, в теле которой есть yield, при вызове не выполняется. Она возвращает объект Generator, и код внутри запускается, только когда кто-то попросит первое значение. Дальше функция работает до очередного yield, отдаёт значение и замирает со всеми локальными переменными, пока её не попросят продолжить

Отсюда ленивость: в памяти в каждый момент лежит одно текущее значение и состояние функции, а не вся последовательность. Генератор реализует Iterator, поэтому его обходят обычным foreach

Что ещё умеет генератор:

  • ключи: yield $id => $row отдаёт пару, и в foreach ($gen as $id => $row) придёт твой ключ. Без явного ключа генератор нумерует значения с нуля
  • yield from отдаёт наружу всё из другого генератора, массива или итератора, а его выражение равно тому, что вложенный генератор вернул через return. Ключи вложенного генератора сохраняются как есть
  • return в генераторе не отдаёт значение в foreach, его читают после обхода через getReturn()
  • send($value) передаёт значение внутрь: выражение $x = yield получает его, и генератор работает до следующего yield. Так пишут корутины-аккумуляторы, но в прикладном коде send встречается редко
  • генератор одноразовый. После того как он ушёл дальше первого yield, rewind() бросает Exception: Cannot rewind a generator that was already run, а второй foreach по закрытому генератору — Cannot traverse an already closed generator. Нужен второй проход — вызови функцию ещё раз

Итераторы и IteratorAggregate

foreach умеет ходить по массивам и по объектам с интерфейсом Traversable. Сам Traversable руками не реализуют, есть два пути

Iterator требует пять методов: current, key, next, rewind, valid. Его пишут, когда нужен полный контроль над состоянием обхода

IteratorAggregate требует один метод getIterator(). Если вернуть из него генератор, коллекция получает обход в три строки. При этом каждый foreach по объекту вызывает getIterator() заново, получает свежий генератор, и проблема одноразовости исчезает

🛠️ На практике

Что захватывает use

<?php
$rate = 10;
$byValue = function (int $x) use ($rate) { return $x * $rate; };
$byRef   = function (int $x) use (&$rate) { return $x * $rate; };
$arrow   = fn(int $x) => $x * $rate;
$rate = 20;
echo $byValue(2), ' ', $byRef(2), ' ', $arrow(2), PHP_EOL; // 20 40 20

$count = 0;
$inc = fn() => ++$count; // увеличивает свою копию
$inc(); $inc();
echo $count, PHP_EOL; // 0

Стрелочная функция захватила $rate, пока та равнялась 10, поэтому $arrow(2) даёт 20, как и use по значению. Только замыкание со ссылкой увидело новое значение. Вывод получен на PHP 8.4

Файл на миллион строк: массив против генератора

CSV в 33 МБ и миллион строк вида 1,user1@example.com,1. Нужно посчитать сумму третьей колонки. Сначала наивно, всё в массив:

<?php
function readAll(string $path): array {
    $rows = [];
    $fh = fopen($path, 'r');
    while (($line = fgets($fh)) !== false) {
        $rows[] = str_getcsv($line, ',', '"', '');
    }
    fclose($fh);
    return $rows;
}

Теперь та же функция, но вместо накопления она отдаёт строку через yield. Блок finally закроет файл, даже если цикл снаружи прервут break:

<?php
function readLazy(string $path): Generator {
    $fh = fopen($path, 'r');
    try {
        while (($line = fgets($fh)) !== false) {
            yield str_getcsv($line, ',', '"', '');
        }
    } finally {
        fclose($fh);
    }
}

$sum = 0;
foreach (readLazy('big.csv') as $row) {
    $sum += (int) $row[2];
}
printf("peak=%.1f MB\n", memory_get_peak_usage() / 1024 / 1024);

На PHP 8.4 memory_get_peak_usage() показал около 330 МБ для массива и около 0,4 МБ для генератора. Точные байты зависят от версии и сборки, важен порядок: файл в 33 МБ раздулся в массиве в 10 раз, потому что каждая строка стала отдельным массивом из трёх строк со своими заголовками. С memory_limit по умолчанию в 128 МБ первый вариант падает с Allowed memory size exhausted, а генератор держит постоянную память на файле любого размера

Выборка из базы

С базой тот же приём, но есть ловушка. Драйвер pdo_mysql по умолчанию буферизует ответ. После query() все строки уже скопированы в память PHP, и генератор поверх fetch() ничего не сэкономит. Для большой выгрузки буферизацию выключают:

<?php
function users(PDO $pdo): Generator {
    $pdo->setAttribute(Pdo\Mysql::ATTR_USE_BUFFERED_QUERY, false);
    $stmt = $pdo->query('SELECT id, email FROM users');
    while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
        yield $row['id'] => $row;
    }
}

У небуферизованного запроса свои ограничения: пока не дочитаны все строки, по этому соединению нельзя отправить другой запрос, и число строк заранее неизвестно. Константа Pdo\Mysql::ATTR_USE_BUFFERED_QUERY появилась в PHP 8.4, старая PDO::MYSQL_ATTR_USE_BUFFERED_QUERY с PHP 8.5 объявлена устаревшей. Другой путь — читать пачками по первичному ключу (WHERE id > ? ORDER BY id LIMIT 1000) и отдавать строки через yield. Так устроен lazyById() в Laravel, подробнее — в модуле про Laravel

Коллекция с повторным обходом

<?php
final class UserList implements IteratorAggregate {
    public function __construct(private array $rows) {}

    public function getIterator(): Generator {
        foreach ($this->rows as $row) {
            yield $row['id'] => $row['name'];
        }
    }
}

foreach по такому объекту можно запускать сколько угодно раз: каждый проход берёт новый генератор

⚠️ Где ошибаются

Ждут, что use увидит поздние изменения. Колбэк собрали в начале функции, а переменную дозаполнили потом. Внутри замыкания осталось старое значение. Либо собирай замыкание после того, как значение готово, либо передавай значение параметром

Ставят & в цикле. foreach ([1, 2, 3] as $i) { $fns[] = function () use (&$i) { return $i; }; } даёт три замыкания на одну и ту же переменную, и все вернут 3. Без & или со стрелочной функцией каждое замыкание получит свою копию: 1, 2, 3

Пытаются менять внешнюю переменную из fn. fn() => $total += $x молча меняет копию, снаружи $total остаётся прежним. Ошибки нет, поэтому баг живёт долго. Для изменения нужна function с use (&$total)

Собирают генератор в массив. iterator_to_array($gen) возвращает всю выборку в память, и выгода генератора пропадает. Вторая ловушка там же: по умолчанию функция сохраняет ключи, а у yield from они повторяются. На генераторе, который отдаёт 1, 2 через yield from, а потом 3, получится [3, 2]: тройка с ключом 0 затёрла единицу. Если ключи не нужны, передавай вторым аргументом false

Проходят генератор дважды. Подсчитали строки одним foreach, потом пошли обрабатывать вторым и получили исключение. Генератор одноразовый: вызови функцию заново или оберни её в IteratorAggregate

🎯 Вопросы с собеседований

Что такое генераторы и yield, зачем они при обработке большого файла?

Генератор — функция с yield, которая при вызове возвращает объект Generator и выполняется по шагам: отдаёт значение, замирает с сохранёнными локальными переменными и продолжает, когда foreach просит следующее. В памяти лежит одно текущее значение, а не вся последовательность. Если читать файл на миллион строк в массив, пиковая память растёт вместе с файлом и упирается в memory_limit. С генератором, который отдаёт строку за строкой из fgets, пик остаётся на уровне сотен килобайт при любом размере файла. Цена — генератор нельзя перемотать и нельзя обратиться к элементу по индексу

Как работают замыкания, use по значению и по ссылке, стрелочные функции, static fn?

Анонимная функция — объект Closure, внешние переменные она видит только через use. use ($x) копирует значение в момент создания замыкания, поэтому поздние изменения снаружи не видны. use (&$x) привязывает ссылку: замыкание видит текущее значение и может его менять. Стрелочная функция fn с PHP 7.4 захватывает все внешние переменные выражения сама, но только по значению, изменить их снаружи она не может. static fn и static function запрещают привязку $this: так колбэк не держит объект, внутри которого его создали

Чем strlen(...) лучше строки 'strlen' или массива [$obj, 'method']?

Синтаксис first-class callable с PHP 8.1 сразу создаёт объект Closure и проверяет, что функция или метод существуют. Строку и массив PHP проверяет только в момент вызова, а IDE и PHPStan не видят в них вызов, поэтому переименование метода ломает код без предупреждения. Кроме того, $this->secret(...) запоминает область видимости в месте создания и работает с приватным методом, а [$this, 'secret'] при вызове снаружи класса упадёт на проверке видимости. По смыслу это то же самое, что Closure::fromCallable()

Что выведет код и почему: замыкания с use (&$i) в цикле foreach?

Выведет 3, 3, 3. Все замыкания держат ссылку на одну переменную $i, а после цикла в ней последнее значение. С use ($i) или со стрелочной функцией каждое замыкание скопирует значение на своей итерации, и получится 1, 2, 3

Можно ли пройти генератор два раза?

Нет. После того как генератор ушёл дальше первого yield, rewind() бросает исключение, а повторный foreach по завершённому генератору тоже падает. Для повторного обхода функцию вызывают заново или делают класс с IteratorAggregate, где getIterator() возвращает новый генератор на каждый foreach. Если данные нужны многократно и помещаются в память, честнее сразу собрать массив

Зачем генератору send и чем return отличается от yield?

send($value) передаёт значение внутрь генератора: оно становится результатом выражения yield, и генератор продолжает работу до следующего yield, значение которого send и вернёт. Так делают аккумуляторы и корутины, в обычном коде это редкость. return не отдаёт значение в foreach, а завершает генератор, и результат читают через getReturn() или получают как значение выражения yield from

📚 Что почитать