🔁 Замыкания, 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'] | Видимость метода проверяется в момент вызова |
| Объект Closure | function () {}, fn() => 1 | Обычное замыкание |
Closure::fromCallable('strlen') | Превращает любую форму в Closure | Старый способ, до 8.1 |
| First-class callable | strlen(...), $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
📚 Что почитать
- Анонимные функции —
use, автоматическая привязка$thisиstaticс примерами из мануала - Стрелочные функции — как устроен автозахват по значению
- Синтаксис генераторов — ключи,
yield from,sendи предупреждение проiterator_to_array - Буферизованные и небуферизованные запросы — почему генератор поверх
pdo_mysqlпо умолчанию не экономит память