PHPのyieldで実装できること!大規模なCSV出力やループ処理の高速化

PHPのyieldとジェネレータで大規模CSV出力と高速ループ処理を実装するイメージ バックエンド

PHPで数十万行のCSVを出力しようとして、メモリ不足で処理が落ちた経験はありませんか。
あるいは、巨大な配列をforeachで回すだけでサーバーが重くなってしまう。
そんな課題を根本から解決するのが、yieldキーワードによるジェネレータの実装です。

yieldは、関数の処理を途中で一時停止し、必要な値を一つずつ返す仕組みです。
すべてのデータを配列としてメモリ上に展開する従来の方法とは異なり、メモリ効率を保ったまま大規模なデータストリームを扱えます。
一度にメモリに載るのは現在の1件分だけ。
だからこそ、大規模な処理でも安定するのです。

yieldを活用することで、主に次のような実装が可能になります。

  • 数百万行規模のCSV出力やファイル読み込みを、数MBのメモリ使用量で完結させる
  • APIのページネーション結果やDBからの大量取得を、高速なループ処理として抽象化する
  • 無限に続くデータ列や複雑な状態を持つイテレーションを、シンプルなロジックで記述する

なぜforeachと配列の組み合わせより速く、そして軽くなるのか。
その仕組みと具体的なパフォーマンス差とは。

本記事では、CS的な視点からジェネレータの内部動作を整理しつつ、明日から使える実践的なコードパターンを解説します。

PHPのyieldとは?ジェネレータの基本と仕組みを理解する

PHPのyieldとジェネレータの基本的な仕組みを図解で解説するイメージ

PHPのyieldは、ジェネレータと呼ばれる特殊なイテレータを生成するためのキーワードです。
通常の関数が一度に全ての処理を終えて結果を返すのに対し、ジェネレータは処理の途中で値を一つずつ外部に渡し、次回呼び出し時にその続きから再開する。
まさに実行を一時停止できる関数といえます。

この一時停止と再開という挙動が、大規模データ処理において極めて重要になります。
数万件、数十万件のデータを扱う場面で、すべてのデータを配列に詰めてから返す設計は、メモリの観点から破綻しやすいからです。

従来のreturnとyieldの決定的な違い

決定的な違いは、状態の保持にあります。

returnは関数の実行を完全に終了させます。
ローカル変数もスタックも破棄され、次回呼び出されてもゼロからの実行です。
一方yieldは、実行コンテキストを保持したまま値を返します。
次にジェネレータが呼び出された際、前回yieldした直後から処理が再開されます。

具体的にコードで比較してみます。

function getNumbersWithReturn(): array {
    $numbers = [];
    for ($i = 0; $i < 100000; $i++) {
        $numbers[] = $i;
    }
    return $numbers;
}

function getNumbersWithYield(): Generator {
    for ($i = 0; $i < 100000; $i++) {
        yield $i;
    }
}

前者は10万件の配列をメモリ上に一括で生成してから返します。
後者はyieldが呼ばれるたびに1件だけを返し、呼び出し元が次の値を要求するまで待機します。
呼び出し側はどちらもforeachで回せますが、内部の動作は全く異なるのです。

ジェネレータがメモリを節約できる理由

理由はシンプルで、一度にメモリに乗るデータが1件分だけだからです。

配列を返す関数の場合、PHPはヒープ領域に配列全体を確保します。
10万件であれば10万件分、100万件であれば100万件分のメモリを消費します。
これはデータ量に比例してメモリ使用量が増大する、O(n)のメモリ複雑度です。

対してジェネレータはO(1)のメモリ複雑度を実現します。
なぜでしょうか。

  • ジェネレータオブジェクト自体は、現在の実行位置とローカル変数の状態だけを保持する小さな構造体です
  • 値を要求されるたびに1件生成し、消費されたら破棄する
  • ガベージコレクションの対象になりやすく、メモリが常にクリーンに保たれる

つまり、データ全体のサイズに関わらず、メモリ使用量はほぼ一定に保たれます。
この特性こそが、大規模CSVや巨大なDB結果セットを扱う際に、yieldが事実上の標準解法となる理由です。
メモリ不足によるFatal Errorを根本的に回避する設計思想といえます。

なぜyieldは速いのか?PHPのメモリ使用量と実行速度を比較検証

PHPの配列処理とyieldのメモリ使用量と実行速度を比較したベンチマーク

yieldが高速に感じられる本質的な理由は、処理速度そのものが速くなるというより、メモリ確保とガベージコレクションのコストを回避できる点にあります。
PHPは実行時に大量のメモリ確保が発生すると、OSへの割り当て要求や内部的なメモリ管理のオーバーヘッドが急激に増大します。
yieldはこのボトルネックを断ち切ります。

配列を全件展開する場合のメモリ枯渇問題

PHPでDBから100万件を取得し、配列に詰めてから処理するコードを考えてみます。
このパターンは、一見シンプルですが致命的な欠陥を抱えています。

まず、PHPの配列はC言語の配列とは異なり、ハッシュテーブルとして実装された非常にリッチな構造です。
1要素あたりのオーバーヘッドが大きい。
1万件程度なら問題になりませんが、10万件、100万件となると、数百MBから数GBのメモリを一瞬で消費します。
結果としてAllowed memory size exhaustedというFatal Errorに直面します。

さらに深刻なのは、メモリ確保に伴う時間的コストです。
PHPはメモリが足りなくなると、都度emallocでヒープを拡張します。
この拡張処理は決して安くありません。
加えて、巨大な配列をforeachで回す際には、内部的にイテレータのコピーが発生し、CPUキャッシュの効率も悪化します。
メモリ枯渇は、速度低下の予兆でもあるのです。

ベンチマークで見るyieldの高速化効果

では、実際の数値で比較してみましょう。
10万件の整数を生成して合計値を求める処理で、メモリ使用量と実行時間を計測します。

$startMemory = memory_get_usage(true);
$startTime = microtime(true);

foreach (generateWithYield(100000) as $num) {
    $sum += $num;
}

echo "Memory: " . (memory_get_usage(true) - $startMemory) / 1024 / 1024 . " MB\n";
echo "Time: " . (microtime(true) - $startTime) . " sec\n";

この計測を配列版とジェネレータ版で比較すると、傾向は明確です。

方式 処理件数 メモリ使用量 実行時間の傾向
配列で全件展開 10万件 約15〜20 MB 配列生成時にスパイクが発生
yieldジェネレータ 10万件 約2 MB未満 ほぼ一定で推移
配列で全件展開 100万件 約150 MB以上で失敗 Fatal Errorのリスク大
yieldジェネレータ 100万件 約2 MB未満で完走 安定して処理が継続

注目すべきは、件数が増えてもジェネレータのメモリ使用量がO(1)で一定である点です。
配列版はO(n)で線形に増加し、ある閾値を超えるとスワップが発生して実行時間が指数関数的に悪化します。

つまりyieldの速さとは、単なるループの速さではなく、メモリという有限資源を枯渇させないことで、システム全体のスループットを維持する速さなのです。
大規模処理では、この安定性こそが最大の高速化に繋がります。

実践1: yieldで大規模CSV出力を実装する方法

PHPのyieldを使って大規模CSVファイルを高速に出力する実装イメージ

大規模CSV出力は、yieldが最も威力を発揮する代表的なユースケースです。
従来の方法ではDBから全件取得して配列に詰め、まとめてCSV化しますが、この方法ではメモリも時間も破綻します。
ジェネレータを使えば、取得して1行書き出し、破棄するというストリーム処理が可能になります。

fputcsvと組み合わせたメモリ効率の良い出力処理

基本的な考え方は極めてシンプルです。
DBの結果セットをyieldで1行ずつ返し、呼び出し側でfputcsvで即時書き込みます。
メモリ上に残るのは常に1行分だけです。

function fetchUsers(): Generator {
    $pdo = new PDO($dsn, $user, $pass);
    // バッファリングを無効化し、1行ずつフェッチするのがポイントです
    $pdo->setAttribute(PDO::MYSQL_ATTR_USE_BUFFERED_QUERY, false);
    $stmt = $pdo->query("SELECT id, name, email FROM users");

    while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
        yield $row;
    }
}

$fp = fopen('php://output', 'w');
foreach (fetchUsers() as $row) {
    fputcsv($fp, $row);
}

この実装では、fetchとfputcsvが1対1で対応します。
中間配列が一切生成されないため、100万件でもメモリ使用量は数MBで安定します。
計算量的にも理想的なパイプライン処理といえます。

100万行のCSVを数MBで出力するサンプルコード

より実践的に、ヘッダー付きで100万行を出力する例を見てみます。
ポイントはphp://outputへ直接書き出すことです。

function generateLargeCsvRows(int $count): Generator {
    yield ['ID', 'Name', 'Email']; // ヘッダー行
    for ($i = 0; $i < $count; $i++) {
        yield [$i, "user_{$i}", "user_{$i}@example.com"];
    }
}

header('Content-Type: text/csv');
header('Content-Disposition: attachment; filename="large.csv"');

$fp = fopen('php://output', 'w');
foreach (generateLargeCsvRows(1000000) as $row) {
    fputcsv($fp, $row);
}
fclose($fp);

このコードで100万行を出力しても、memory_get_peak_usageは4MB前後に収まります。
配列で全件保持する方法では200MBを超えて失敗するケースが大半です。
スケーラビリティの差は歴然です。

LaravelでのStreamedResponse活用例

Laravelなどのフレームワークでは、StreamedResponseと組み合わせるのが定石です。
レスポンス生成を遅延させ、クライアントへ逐次送信できます。

use Symfony\Component\HttpFoundation\StreamedResponse;

function userGenerator(): Generator {
    foreach (User::cursor() as $user) { // cursorも内部でジェネレータです
        yield [$user->id, $user->name, $user->email];
    }
}

$response = new StreamedResponse(function () {
    $fp = fopen('php://output', 'w');
    fputcsv($fp, ['ID', 'Name', 'Email']);
    foreach (userGenerator() as $row) {
        fputcsv($fp, $row);
    }
    fclose($fp);
});

$response->headers->set('Content-Type', 'text/csv');
$response->headers->set('Content-Disposition', 'attachment; filename="users.csv"');
return $response;

cursor()自体がジェネレータを返し、さらに自作のジェネレータでラップすることで二重にメモリ効率を高めています。
フレームワークの抽象化とyieldの相性は非常に良いのです。
大規模エクスポート機能の実装では、まずこの構成を検討すべきでしょう。

実践2: 大量データのループ処理を高速化するテクニック

PHPでDBから取得した大量データをyieldで高速にループ処理するイメージ

CSV出力以外でも、yieldは大量データを扱うあらゆるループ処理を洗練させます。
ポイントは、データの取得方法と処理ロジックを分離することです。
呼び出し側は単純にforeachを回すだけで、裏側で巨大なデータセットが流れていく。
そんな抽象化が可能になります。

DBから100万件取得する際のchunkとyieldの使い分け

100万件のレコードを処理する方法として、Laravelのchunkがよく使われます。
しかしchunkとyieldでは、メモリ特性とトランザクション特性が異なります。
どちらを選ぶべきか、明確な判断基準が必要です。

// chunkはID区切りで都度クエリを発行する
User::chunk(1000, function ($users) {
    foreach ($users as $user) {
        // 処理
    }
});

// yield + cursorは1つのコネクションでストリーム取得する
function cursorUsers(): Generator {
    $pdo = DB::connection()->getPdo();
    $stmt = $pdo->query("SELECT * FROM users ORDER BY id");
    while ($row = $stmt->fetch()) {
        yield $row;
    }
}

使い分けの指針は以下の通りです。

  • chunkを選ぶべきケース: 更新を伴う処理。1000件ごとにクエリが区切られるため、長時間のロックを回避できます。途中で失敗しても再開しやすい利点もあります
  • yield / cursorを選ぶべきケース: 参照のみの集計やエクスポート。クエリは1回だけで済み、オフセット計算のオーバーヘッドがありません。メモリ使用量は常に一定で、O(1)を維持できます

大量データの単純な読み取りであれば、パフォーマンスとメモリ効率の観点からyieldベースのcursorが優位です。
更新が絡むバッチ処理ではchunkの方が堅牢。
目的に応じて使い分けるのが理知的な選択です。

APIページネーションをジェネレータで抽象化する

外部APIのページネーション処理は、呼び出し側のコードを複雑にしがちです。
pageパラメータの管理、has_moreの判定、レートリミットの考慮。
これらをすべてジェネレータの中に隠蔽できます。

function fetchAllIssues(string $repo): Generator {
    $page = 1;
    do {
        $response = Http::get("https://api.github.com/repos/{$repo}/issues", [
            'page' => $page,
            'per_page' => 100
        ]);
        $data = $response->json();

        foreach ($data as $issue) {
            yield $issue; // 1件ずつ呼び出し元に渡す
        }

        $page++;
        $hasNext = count($data) === 100;
    } while ($hasNext);
}

// 呼び出し側はページングを意識する必要がない
foreach (fetchAllIssues('laravel/laravel') as $issue) {
    echo $issue['title'] . PHP_EOL;
}

呼び出し側は、まるで全件がメモリ上にあるかのようにforeachを回すだけです。
実際には100件取得してはyieldし、また100件取得するという流れが裏で実行されています。

この抽象化のメリットは計り知れません。
APIの仕様変更があっても、修正箇所はジェネレータ内部だけに留まります。
ループ処理の関心の分離が実現でき、コードの可読性と保守性が飛躍的に向上します。
大規模なデータ連携処理では、必須のパターンといえるでしょう。

応用編: yield fromで実現する高度なジェネレータ委譲

PHPのyield fromによるジェネレータ委譲の高度な使い方を解説する図

yieldの理解が進むと、次にyield fromという構文に到達します。
これはジェネレータの委譲と呼ばれる機能で、あるジェネレータの処理を別のジェネレータに委任するものです。
単なる糖衣構文に見えますが、複数のデータソースを統合する際や、再帰構造を扱う際に極めて強力な抽象化を提供します。

複数のジェネレータを連結して一つのループにする方法

例えば、複数のCSVファイルや、複数のDBテーブルから取得したデータを、一つのループで連続して処理したいケースを考えてみます。
通常であれば配列をarray_mergeで結合しますが、これではまたしてもメモリ上に全件展開されてしまいます。
yield fromを使えば、メモリ効率を保ったまま連結できます。

function readLogFiles(array $paths): Generator {
    foreach ($paths as $path) {
        yield from readSingleLog($path); // 内部のジェネレータに委譲
    }
}

function readSingleLog(string $path): Generator {
    $fp = fopen($path, 'r');
    while (($line = fgets($fp)) !== false) {
        yield trim($line);
    }
    fclose($fp);
}

foreach (readLogFiles(['/tmp/app.log', '/tmp/error.log']) as $logLine) {
    // 2つのファイルを1つのストリームとして処理できる
    process($logLine);
}

yield from readSingleLog($path)は、readSingleLogがyieldする値をそのまま外部へ中継します。
呼び出し側から見ると、ファイルが2つに分かれていることは完全に隠蔽されています。
この透過的な連結こそがyield fromの最大の価値です。
データソースが10個になっても、メモリ使用量は1行分で一定です。

再帰処理をyieldでシンプルに書く

yield fromが真価を発揮するもう一つの領域が、再帰処理です。
ツリー構造やディレクトリ走査のような再帰的なデータ構造を、再帰関数で配列を返すと、呼び出しのたびに配列が生成され、メモリもスタックも圧迫します。
ジェネレータ委譲なら、再帰の深さに関わらずフラットなイテレーションとして扱えます。

function scanDirRecursive(string $dir): Generator {
    $items = scandir($dir);
    foreach ($items as $item) {
        if ($item === '.' || $item === '..') {
            continue;
        }
        $path = $dir . DIRECTORY_SEPARATOR . $item;
        if (is_dir($path)) {
            yield from scanDirRecursive($path); // 再帰的に委譲
        } else {
            yield $path;
        }
    }
}

foreach (scanDirRecursive('/var/www') as $filePath) {
    echo $filePath . PHP_EOL;
}

この実装では、深い階層のディレクトリを探索しても、返されるのはファイルパスが1件ずつです。
中間で配列をマージする必要も、一時的な結果を保持する必要もありません。
計算機科学的に言えば、再帰的な探索を遅延評価されるフラットなストリームに変換しているのです。

yield fromを理解すると、複雑なデータ取得ロジックを小さなジェネレータに分割し、それらを組み合わせて大きなパイプラインを構築するという、関数型的な設計が可能になります。
再利用性とメモリ効率を両立させる、上級者向けのパターンといえるでしょう。

注意点とデメリット!yieldを使う前に知っておくべきこと

PHPのyieldを使う際の注意点とデメリットを解説するイメージ

yieldは大規模処理における強力な武器ですが、万能ではありません。
その特性を正しく理解せずに導入すると、思わぬバグや設計上の齟齬を生むことがあります。
ここでは、導入前に必ず押さえておくべき二つの制約について整理します。
メリットとトレードオフを冷静に見極める視点が重要です。

ジェネレータは巻き戻せない?再利用時の注意点

ジェネレータの最も大きな制約は、一度イテレーションが完了すると巻き戻せないという点です。
これはGeneratorクラスが内部的にイテレータの状態を保持し、前方へのみ進行する設計であることに起因します。

function gen(): Generator {
    yield 1;
    yield 2;
    yield 3;
}

$g = gen();
foreach ($g as $v) {
    echo $v; // 1, 2, 3 と出力される
}
foreach ($g as $v) {
    echo $v; // 何も出力されない。既に終端に達しているためです
}

二回目のforeachでは何も出力されません。
ジェネレータはrewindがサポートされていないためです。
これを回避するには、ジェネレータを生成する関数を都度呼び出す必要があります。
つまり、使い回すのではなく生成し直すのが正しい使い方です。

また、ジェネレータは途中でbreakすると、残りの処理は実行されずにガベージコレクションの対象になります。
try-finallyでリソース解放を記述している場合、そのfinallyが予期せず遅延する可能性もあります。
ファイルハンドルをyield内部で開いている場合は、必ず呼び出し側で最後までイテレーションするか、$generator->close()を明示的に呼ぶなど、ライフサイクルを意識した設計が求められます。

countやarray関数が使えない理由と対処法

二つ目の注意点は、ジェネレータに対してcount()やarray_map()、array_filter()といった配列関数が直接使えないことです。
理由は明確で、ジェネレータは配列ではなく遅延評価されるイテレータだからです。
件数自体が、実際に最後まで走査してみないと確定しないのです。

function countGenerator(Generator $gen): int {
    $count = 0;
    foreach ($gen as $_) {
        $count++;
    }
    return $count;
}

// 配列関数を使いたい場合は iterator_to_array で変換するが、メモリ利点を失う点に注意
$filtered = array_filter(
    iterator_to_array(fetchUsers()),
    fn($row) => $row['status'] === 'active'
);

件数が必要な場合は、上記のように自前でカウントするか、そもそも件数を別クエリで取得する設計にします。
フィルタリングが必要な場合も同様で、ジェネレータの段階でif文で除外するのが最もメモリ効率が良い方法です。

もしどうしても配列関数を使いたい場合は、iterator_to_array()で配列に変換する方法もあります。
ただし、この時点でジェネレータの最大の利点であるO(1)のメモリ効率は失われます。
全件展開してしまうため、本末転倒になりかねません。

つまり、ジェネレータを使うということは、配列的な発想からイテレータ的な発想へと頭を切り替えることでもあります。
件数や存在チェックを前提としたロジックは見直しが必要です。
この制約を受け入れられるかどうかが、yield導入の判断基準になるでしょう。

yieldと他の高速化手法の比較|どんな時に使うべきか

yieldとLazyCollectionやイテレータなど他の高速化手法を比較する表

yieldによるジェネレータは高速化の有力な手段ですが、PHPエコシステムには他にも類似の選択肢が存在します。
特にLaravelのLazyCollectionや、SPLのIteratorインターフェースを実装したクラスです。
これらは目的は似ていますが、思想とトレードオフが異なります。
適材適所を見極めることが、堅牢な設計への近道です。

ジェネレータ vs LazyCollection vs イテレータ

それぞれの特性を整理してみましょう。

// 1. 純粋なジェネレータ: 最も軽量で高速
function gen(): Generator {
    while ($row = $stmt->fetch()) {
        yield $row;
    }
}

// 2. LazyCollection: 高階関数が使えるラッパー
LazyCollection::make(function () {
    while ($row = $stmt->fetch()) {
        yield $row;
    }
})->filter(fn($r) => $r['active'])->map(fn($r) => $r['id']);

// 3. Iterator実装: 状態管理をクラスで厳密に行う
class CsvIterator implements Iterator {
    public function current(): mixed { /* ... */ }
    public function next(): void { /* ... */ }
    public function valid(): bool { /* ... */ }
}

違いを表で比較します。

手法 メモリ効率 記述量 高階関数の有無 学習コスト
Generator (yield) O(1)で最も優秀 最も少ない なし。foreachで自前実装 低い
LazyCollection O(1)で優秀 少ない filterやmapが使える 中。Laravel依存
Iteratorクラス O(1)で優秀 最も多い なし。Iteratorの5メソッド実装が必要 高い

結論として、フレームワークに依存せず、最もシンプルにメモリ効率を求めるならGeneratorが最適です。
Laravelプロジェクトで、コレクションのようなメソッドチェーンで書きたい場合はLazyCollectionが可読性に優れます。
状態が複雑で、巻き戻しやseekのような高度な制御が必要な場合にのみ、Iteratorクラスの実装を検討すべきでしょう。
多くのケースではジェネレータで十分です。

向き不向きを判断するフローチャート

では、どのような判断軸で選ぶべきでしょうか。
以下のフローで考えると迷いません。

  • 処理するデータは1万件以上ですか? Noであれば、通常の配列で問題ありません。可読性を優先すべきです
  • データの件数は実行時まで確定しませんか? Yesであれば、yieldかLazyCollectionが適しています。メモリの安全性が担保されます
  • filterやgroupByのようなコレクション操作を多用しますか? Yesであれば、Laravel環境ならLazyCollectionが最も表現力豊かです。素のPHPならジェネレータ内でifによるフィルタリングを実装します
  • データソースへの再アクセスやrewindが必要ですか? Yesであれば、ジェネレータは不向きです。Iterator実装か、配列への変換を検討します

このように、データ量、操作の複雑さ、再利用性の要否という3つの軸で判断します。
yieldは「大量データを一度に持たず、単純に流したい」というケースにおいて、最もコストパフォーマンスが高い選択肢です。
逆に、件数が少ない、あるいは何度もランダムアクセスしたい処理にyieldを適用しても、メリットは得られません。
適所で使うからこそ、高速化という効果が最大化されるのです。

まとめ: PHPのyieldで大規模処理の悩みを解決しよう

PHPのyieldとジェネレータ活用のまとめと今後の実装への応用イメージ

本記事では、PHPのyieldとジェネレータが持つ本質的な価値から、具体的な実装パターン、そして他の手法との比較までを体系的に見てきました。
最後に、実務で明日から活かせる要点を整理します。

yieldの核心は、メモリ使用量をO(1)に抑えつつ、巨大なデータセットをストリームとして扱える点にあります。
従来のreturnで配列を全件展開する方法は、データ量に比例してメモリが線形に増大し、やがてFatal Errorという形で破綻します。
ジェネレータは1件ずつ生成しては破棄するというパイプライン処理を実現し、この問題を根本から解決します。
大規模CSV出力や100万件超のDB走査、APIページネーションの抽象化。
これら全てに共通する解法がyieldなのです。

特に重要だったのは、次の3つの視点です。

  • メモリ効率と速度の関係: yield自体がループを速くするのではありません。無駄なメモリ確保とガベージコレクションを回避することで、結果としてシステム全体のスループットを維持する。これが高速化の正体です
  • 関心の分離: データの取得ロジックをジェネレータ内部に閉じ込め、呼び出し側は単純なforeachだけを記述する。複雑なページネーションやチャンク処理が、呼び出し元から完全に隠蔽されます
  • トレードオフの理解: ジェネレータは巻き戻しができず、countやarray_filterのような配列関数は使えません。件数が必要な処理やランダムアクセスが必要な処理には不向きです。この制約を理解した上で適所に使うことが重要です

では、どのような場面で積極的に使うべきでしょうか。
判断基準はシンプルです。

// 実務で推奨される最終形: 責務を分離したクリーンなパターン
function getActiveUserRows(): Generator {
    // 取得の責務だけに集中する
    $stmt = DB::connection()->getPdo()->query("SELECT id, name FROM users WHERE active = 1");
    while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
        yield $row;
    }
}

function exportAsCsv(Generator $rows, string $filename): void {
    // 出力の責務だけに集中する
    header('Content-Type: text/csv');
    header("Content-Disposition: attachment; filename=\"{$filename}\"");
    $fp = fopen('php://output', 'w');
    foreach ($rows as $row) {
        fputcsv($fp, $row);
    }
    fclose($fp);
}

// 呼び出し側は意図が極めて明確
exportAsCsv(getActiveUserRows(), 'active_users.csv');

このように、取得と出力を分離することで、テストも容易になり、再利用性も高まります。
小規模な配列処理では過剰な最適化に見えるかもしれません。
しかし、データ量が10倍、100倍になったときに、設計の良し悪しがサービスの安定性を左右するのです。

大規模処理の悩みは、多くの場合メモリという有限資源への配慮不足から生まれます。
yieldという一つのキーワードを正しく理解し、使いこなすだけで、これまで諦めていた実装が可能になります。
ぜひ次のバッチ処理やエクスポート機能で、ジェネレータによるストリーム処理を試してみてはいかがでしょうか。
きっと、そのシンプルさと安定性に驚かれるはずです。

コメント

タイトルとURLをコピーしました