PHP Generator'lar: yield, yield from ve Bellek Kullanımı

Generator, içinde yield bulunan bir fonksiyondur. Onu çağırmak gövdeyi çalıştırmaz; foreach döngüsünün üzerinde dolaşabileceği bir Generator nesnesi döndürür. Her yield $value döngüye bir değer verir ve döngü bir sonrakini isteyene kadar fonksiyonu duraklatır, böylece değerler önce bir dizide toplanmak yerine birer birer üretilir.

<?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";
}

Çıktı generator ile döngü arasında gidip gelir: her değer yalnızca döngü onu istediğinde üretilir.

Generator'lar bellek tasarrufu sağlar

range(1, 1000000) döngü başlamadan önce bir milyon tam sayıdan oluşan bir dizi oluşturur. Aynı sayıları yield eden bir generator ise hiçbir zaman birden fazlasını tutmaz. Çalıştırın ve her sürümün ihtiyaç duyduğu belleği karşılaştırı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);

İki döngü de aynı toplamı, 500000500000 yazdırır, ama dizi sürümü extra memory 16.0 MB, generator ise extra memory 0.0 MB bildirir. Fark veriyle birlikte büyür. Generator'ları büyük dosyalar, veritabanı sonuçları ve API sayfaları için kullanışlı yapan da aynı fikirdir: bir öğeyi işleyin, bırakın, sonrakini alın.

Anahtarları ve değerleri yield etme

yield $key => $value foreach ($gen as $key => $value) ifadesinin alacağı anahtarı belirler. Anahtar olmadan bir generator değerlerini bir liste gibi 0'dan numaralar. Yaygın bir kullanım, bir dosyayı satır numaralarıyla satır satır okumaktır:

<?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";
    }
}

Bellekte her seferinde yalnızca bir satır olduğu için aynı fonksiyon 2 GB'lık bir log dosyasını da işler. Burada kullanılan dosya fonksiyonları fopen() ve fgets() sayfasında anlatılıyor.

Sonsuz diziler ve tembel işlem hatları

Bir generator sonsuza kadar dönebilir, çünkü yalnızca tüketicinin istediği kadar çalışır. break ile durdurun ya da onu ilk birkaç değeri alan başka bir generator ile sarın. Küçük generator'ları zincirlemek her adımın tembel olduğu bir işlem hattı verir:

<?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() kendi başına hiç bitmez, ama program biter: take() istenen sayıdan sonra istemeyi bırakır ve bunun ötesinde hiçbir şey hesaplanmaz.

yield from: başka bir generator'a devretme

yield from bir dizinin, bir yineleyicinin veya başka bir generator'ın her değerini iletir. Bir generator'ı daha küçüklerine bölmenin ya da iç içe bir yapıyı özyinelemeli dolaşmanın yolu budur:

<?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 iç anahtarları korur, bu yüzden iki dizi de 0 ve 1 anahtarlarını yield eder. iterator_to_array() ardından a ve b değerlerinin üzerine yazar. Yalnızca değerler önemli olduğunda ikinci argüman olarak false verin.

send() ve getReturn()

Bir generator değer de alabilir. $x = yield; duraklar ve bekler; $gen->send($value) generator'ı o yield ifadesinin sonucu $value olacak şekilde devam ettirir. Ayrıca bir generator son bir değeri return ile döndürebilir; bitince onu getReturn() ile okursunuz.

<?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";

Kodların çoğu send() gerektirmez; günlük kullanım foreach ile tembel okumaktır. Eşyordam (coroutine) kütüphanelerinin arkasındaki yapı taşı budur.

Bir generator üzerinde yalnızca bir kez dolaşılabilir

Generator'lar ileri gider ve geri sarılamaz. Bir foreach onu tükettikten sonra aynı nesne üzerindeki ikinci bir döngü hata fırlatır:

<?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";
}

Çözüm, her geçiş için generator fonksiyonunu yeniden çağırmaktır, foreach (colors() as $c), ya da değerlere gerçekten iki kez ihtiyaç duyduğunuzda onları bir kez iterator_to_array(colors(), false) ile toplamaktır. Bunu sık yapıyorsanız o veri için doğru seçim düz bir diziydi.