Generator trong PHP: yield, yield from và bộ nhớ

Generator là một hàm có chứa yield. Gọi hàm này không chạy phần thân; nó trả về một đối tượng Generator mà foreach có thể lặp qua. Mỗi yield $value trao một giá trị cho vòng lặp và tạm dừng hàm cho đến khi vòng lặp xin giá trị tiếp theo, nên các giá trị được tạo ra từng cái một thay vì gom vào một mảng trước.

<?php
function countTo(int $n): Generator
{
    for ($i = 1; $i <= $n; $i++) {
        echo "(making $i) ";
        yield $i;
    }
}

foreach (countTo(3) as $number) {
    echo "got $number\n";
}

Đầu ra xen kẽ giữa generator và vòng lặp: mỗi giá trị chỉ được tạo ra khi vòng lặp yêu cầu.

Generator tiết kiệm bộ nhớ

range(1, 1000000) tạo một mảng một triệu số nguyên trước khi vòng lặp bắt đầu. Một generator yield cùng những số đó thì không bao giờ giữ quá một số. Hãy chạy và so sánh bộ nhớ mà mỗi phiên bản cần:

<?php
function numbers(int $max): Generator
{
    for ($i = 1; $i <= $max; $i++) {
        yield $i;
    }
}

$start = memory_get_usage();
$sum = 0;
foreach (range(1, 1_000_000) as $n) {
    $sum += $n;
}
$arrayPeak = memory_get_peak_usage() - $start;

memory_reset_peak_usage();
$start = memory_get_usage();
$sum2 = 0;
foreach (numbers(1_000_000) as $n) {
    $sum2 += $n;
}
$genPeak = memory_get_peak_usage() - $start;

printf("array:     sum %d, extra memory %.1f MB\n", $sum, $arrayPeak / 1048576);
printf("generator: sum %d, extra memory %.1f MB\n", $sum2, $genPeak / 1048576);

Cả hai vòng lặp in ra cùng một tổng, 500000500000, nhưng phiên bản dùng mảng báo extra memory 16.0 MB còn generator báo extra memory 0.0 MB. Khoảng cách này càng lớn khi dữ liệu càng nhiều. Cũng chính ý tưởng này làm generator hữu ích với tệp lớn, kết quả truy vấn cơ sở dữ liệu và các trang của API: xử lý một phần tử, bỏ nó đi, lấy phần tử tiếp theo.

Yield kèm khóa và giá trị

yield $key => $value đặt khóa mà foreach ($gen as $key => $value) nhận được. Không có khóa, generator đánh số các giá trị từ 0, giống một danh sách. Một cách dùng phổ biến là đọc tệp từng dòng kèm số dòng:

<?php
file_put_contents('log.txt', "boot ok\nERROR disk full\nuser login\nERROR timeout\n");

function readLines(string $path): Generator
{
    $handle = fopen($path, 'r');
    $lineNo = 0;
    while (($line = fgets($handle)) !== false) {
        $lineNo++;
        yield $lineNo => rtrim($line, "\n");
    }
    fclose($handle);
}

foreach (readLines('log.txt') as $no => $line) {
    if (str_starts_with($line, 'ERROR')) {
        echo "line $no: $line\n";
    }
}

Mỗi lúc chỉ có một dòng nằm trong bộ nhớ, nên cùng hàm này xử lý được cả tệp log 2 GB. fopen() và fgets() giải thích các hàm xử lý tệp được dùng ở đây.

Dãy vô hạn và pipeline lười

Generator có thể lặp mãi mãi, vì nó chỉ chạy đến chừng nào nơi dùng còn yêu cầu. Dừng bằng break, hoặc bọc nó trong một generator khác chỉ lấy vài giá trị đầu. Nối các generator nhỏ với nhau tạo thành một pipeline mà mọi bước đều lười (lazy):

<?php
function fibonacci(): Generator
{
    [$a, $b] = [0, 1];
    while (true) {
        yield $a;
        [$a, $b] = [$b, $a + $b];
    }
}

function take(iterable $items, int $n): Generator
{
    if ($n <= 0) {
        return;
    }
    foreach ($items as $item) {
        yield $item;
        if (--$n === 0) {
            return;
        }
    }
}

function filter(iterable $items, callable $keep): Generator
{
    foreach ($items as $item) {
        if ($keep($item)) {
            yield $item;
        }
    }
}

echo implode(' ', iterator_to_array(take(fibonacci(), 10), false)), "\n";

$evenFibs = take(filter(fibonacci(), fn($x) => $x % 2 === 0), 6);
echo implode(' ', iterator_to_array($evenFibs, false)), "\n";

fibonacci() tự nó không bao giờ kết thúc, vậy mà chương trình vẫn chạy xong: take() ngừng yêu cầu khi đã đủ số lượng, và không có gì vượt quá mức đó được tính cả.

yield from: giao việc cho generator khác

yield from chuyển tiếp mọi giá trị của một mảng, một iterator hoặc một generator khác. Đây là cách chia một generator thành các generator nhỏ hơn, hoặc duyệt đệ quy một cấu trúc lồng nhau:

<?php
function flatten(array $items): Generator
{
    foreach ($items as $item) {
        if (is_array($item)) {
            yield from flatten($item);   // recurse
        } else {
            yield $item;
        }
    }
}

$nested = [1, [2, 3, [4, 5]], 6, [[7]]];
foreach (flatten($nested) as $v) {
    echo $v, ' ';
}
echo "\n";

// Careful: keys from yield from can repeat
function letters(): Generator
{
    yield from ['a', 'b'];
    yield from ['c', 'd'];
}
print_r(iterator_to_array(letters()));         // keys 0,1,0,1: values overwritten
print_r(iterator_to_array(letters(), false));  // a plain list

yield from giữ nguyên khóa bên trong, nên cả hai mảng đều yield các khóa 0 và 1. Sau đó iterator_to_array() ghi đè a và b. Hãy truyền false làm đối số thứ hai bất cứ khi nào bạn chỉ quan tâm đến giá trị.

send() và getReturn()

Generator cũng có thể nhận giá trị. $x = yield; tạm dừng và chờ; $gen->send($value) cho generator chạy tiếp với $value là kết quả của yield đó. Generator còn có thể return một giá trị cuối cùng, bạn đọc nó bằng getReturn() sau khi generator đã chạy xong.

<?php
function runningAverage(): Generator
{
    $total = 0;
    $count = 0;
    $average = null;
    while (true) {
        $value = yield $average;   // send() puts a value here
        if ($value === null) {
            return $count;         // final result
        }
        $total += $value;
        $count++;
        $average = $total / $count;
    }
}

$avg = runningAverage();
$avg->current();                   // run to the first yield

foreach ([10, 20, 60] as $n) {
    echo "after $n: ", $avg->send($n), "\n";
}

$avg->send(null);                  // ends the loop
echo "values seen: ", $avg->getReturn(), "\n";

Phần lớn code không bao giờ cần đến send(); đọc lười với foreach mới là cách dùng hằng ngày. Đây là nền tảng của các thư viện coroutine.

Generator chỉ lặp được một lần

Generator chạy tiến và không thể quay lại từ đầu. Một khi foreach đã dùng hết nó, vòng lặp thứ hai trên cùng đối tượng sẽ ném lỗi:

<?php
// This throws an Exception on purpose: the generator is already finished
function colors(): Generator
{
    yield 'red';
    yield 'green';
}

$gen = colors();
foreach ($gen as $c) {
    echo $c, "\n";
}
foreach ($gen as $c) {   // second pass
    echo $c, "\n";
}

Cách sửa là gọi lại hàm generator cho mỗi lượt, foreach (colors() as $c), hoặc gom giá trị một lần bằng iterator_to_array(colors(), false) khi bạn thật sự cần dùng chúng hai lần. Nếu thấy mình thường xuyên làm vậy, thì một mảng thông thường mới là lựa chọn đúng cho dữ liệu đó.