JavaScriptのyieldを避けるべきケースとは?ジェネレータ関数に頼らずに状態管理を安全に行う代替パターン

JavaScriptのyieldとジェネレータ関数を使わない安全な状態管理パターンのイメージ プログラミング言語

JavaScriptのyieldは、ジェネレータ関数の実行を一時停止し、必要なタイミングで再開できる便利な仕組みです。
反復処理や遅延評価など、処理の流れを細かく制御したい場面では強力な選択肢になります。
一方で、yieldによって処理の途中に状態が残る設計は、コードを読んだだけでは現在の状態や実行順序を把握しにくくすることがあります。

特に、アプリケーションの状態管理や非同期処理、複数箇所から共有される状態を扱うコードでは、「一時停止できる」ことと「安全に状態を管理できる」ことは別問題です。
ジェネレータ関数を導入した結果、状態の変化が暗黙的になり、デバッグやテスト、保守が難しくなるケースもあります。

では、どのような状況でyieldを避けるべきなのでしょうか。
そして、ジェネレータ関数を使わずに、状態の遷移をより明示的かつ安全に表現するにはどう設計すればよいのでしょうか。

この記事では、yieldとジェネレータ関数の仕組みを整理したうえで、使わないほうがよいケースを具体的に切り分けます。
そのうえで、クロージャ、明示的な状態オブジェクト、イテレータ、async/awaitなどを使った代替パターンを比較し、状態管理を予測しやすいコードへ設計するための考え方を解説します。

  1. JavaScriptのyieldとは?ジェネレータ関数の基本と状態管理の仕組み
    1. yieldは「値を返す」だけではなく実行状態を保持する
    2. ジェネレータ関数と状態管理は同じものではない
  2. yieldが便利なケースとジェネレータ関数が活きる場面
    1. 大量のデータを逐次処理するとき
    2. 無限シーケンスや遅延評価を表現するとき
    3. for…ofと組み合わせて反復処理を簡潔にする
    4. 外部から処理の進行を制御したいとき
    5. yieldを採用する前に確認したい判断基準
  3. JavaScriptでyieldを避けるべきケースとは?状態管理で注意したい問題
    1. 共有状態を複数の処理から操作する場合
    2. 状態遷移を外部から明確に確認したい場合
    3. 非同期処理の流れを表現するためだけにyieldを使う場合
    4. デバッグやテストで現在の状態を確認しにくい場合
    5. チーム開発で処理の意図を共有しにくい場合
    6. yieldを避けるべきか判断するチェックポイント
  4. yieldによる暗黙的な状態がコードの可読性と保守性を下げる理由
    1. 実行位置が状態になるとコードを読み解く負担が増える
    2. next()の呼び出し回数に意味が依存しやすい
    3. 条件分岐が増えるほど状態遷移を追いにくくなる
    4. デバッグ時に「現在の状態」を観測しにくい
    5. テストが実装の手順に引っ張られやすい
    6. 暗黙的な状態を減らすことが保守性につながる
  5. 状態管理を安全にする代替パターン1:クロージャで状態を明示的に管理する
    1. クロージャで状態をカプセル化する基本的な考え方
    2. 状態を直接公開せず、不正な変更を防ぐ
    3. 状態の更新ルールを関数に集約する
    4. クロージャとジェネレータの違いを整理する
    5. クロージャにも注意点がある
  6. 状態管理を安全にする代替パターン2:状態オブジェクトと関数で遷移を明確にする
    1. 現在の状態をデータとして表現する
    2. 状態を変更する処理を関数へ分離する
    3. 状態遷移を明示すると仕様と実装を対応させやすい
    4. 状態更新を純粋関数に近づけるメリット
    5. 状態と副作用を分離しておく
    6. 状態オブジェクト方式にも限界はある
  7. 状態管理を安全にする代替パターン3:async/awaitで非同期処理を分かりやすく書く
    1. yieldを非同期処理に使う設計が複雑になりやすい理由
    2. async/awaitで非同期処理と状態更新を分離する
    3. awaitは処理の順序をコード上で追いやすくする
    4. 非同期処理中の状態遷移を明示する
    5. エラー処理もasync/awaitの流れに組み込みやすい
    6. async/awaitでも状態と制御フローを混同しない
  8. yieldと代替パターンを比較して選ぶ基準
    1. まず「何を管理したいのか」を考える
    2. yieldを選んでよいケース
    3. 状態を管理するなら状態をデータとして表現する
    4. 非同期処理ならasync/awaitを第一候補にする
    5. チーム開発では「読める人の数」も判断材料にする
    6. 判断に迷ったときの実践的な基準
  9. 実装時に確認したい状態管理の設計ポイントとテスト方法
    1. 状態の種類と意味を最初に定義する
    2. 状態を変更できる場所を限定する
    3. 副作用と状態遷移を分離する
    4. 状態遷移をテーブルにして考える
    5. テストでは「next()の回数」ではなく状態を検証する
    6. 非同期処理では競合状態もテストする
    7. 境界条件と不正な操作を先に考える
  10. JavaScriptのyieldを避けるべきケースと安全な状態管理のまとめ
    1. yieldを避けたほうがよい代表的なケース
    2. 安全な状態管理では状態を観測可能にする
    3. 非同期処理と状態管理を混ぜない
    4. テストでは実装詳細ではなく振る舞いを確認する
    5. 最終的な判断基準

JavaScriptのyieldとは?ジェネレータ関数の基本と状態管理の仕組み

JavaScriptのyieldとジェネレータ関数による処理の一時停止を示すイメージ

JavaScriptのyieldは、ジェネレータ関数の実行を途中で一時停止し、後からその続きの処理を再開するための構文です。
通常の関数が呼び出されると基本的には最後まで処理を進めて値を返しますが、ジェネレータ関数ではyieldに到達した時点で処理を中断できます。
この性質によって、処理の進行状況そのものを状態として保持できる点が大きな特徴です。

ジェネレータ関数は、function*という構文で定義します。
そして、その関数を呼び出すと通常の戻り値ではなく、ジェネレータオブジェクトが返されます。
ジェネレータオブジェクトに対してnext()を呼び出すことで処理が進み、yieldした値と、処理が終了したかどうかを示すdoneを受け取れます。
つまり、関数を一度実行して終了させるのではなく、実行途中の状態を保持したまま段階的に進めるというモデルです。

例えば、複数の値を順番に生成する処理では、ジェネレータ関数の特性が分かりやすく表れます。

function* numbers() {
  yield 1;
  yield 2;
  yield 3;
}

const generator = numbers();
generator.next(); // { value: 1, done: false }
generator.next(); // { value: 2, done: false }
generator.next(); // { value: 3, done: false }
generator.next(); // { value: undefined, done: true }

ここで重要なのは、2回目のnext()を呼び出したときに、ジェネレータ関数が最初から実行されるわけではないことです。
1回目のnext()で最初のyieldまで進んだ実行状態が保持され、次のnext()では、その続きから処理が再開されます。
ローカル変数の値や、次に実行すべき位置もジェネレータの内部状態として維持されます。

この仕組みは、単純な反復処理だけでなく、状態を持った処理を段階的に進める用途にも利用できます。
例えば、状態に応じて異なる処理を実行し、次のyieldで停止するような構造です。
一般的なループでは外側から見えにくい「現在どこまで処理したのか」という情報を、ジェネレータ自身が保持できます。
これはジェネレータの強みである一方、状態管理という観点では注意すべきポイントにもなります。

yieldは「値を返す」だけではなく実行状態を保持する

yieldを理解するとき、単に「値を返すための構文」と捉えると本質を見誤りやすくなります。
returnとの大きな違いは、returnが関数の実行を終了させるのに対して、yieldは実行を一時停止させることです。
したがって、ジェネレータには「値」だけでなく「次にどこから処理を再開するか」という実行コンテキストが存在します。

この違いは、状態管理を考えるうえで非常に重要です。
状態とは、単にオブジェクトに保存されたデータだけではありません。
処理の進行位置、保持しているローカル変数、次に実行される処理なども、広い意味ではプログラムの状態に含まれます。
ジェネレータは、こうした状態を自然にカプセル化できる仕組みです。

例えば、ジェネレータ内部でカウンターを増やしながら値を生成する場合、カウンターの現在値を外部のコードが直接管理する必要はありません。
ジェネレータを操作する側はnext()を呼び出すだけで、内部の状態遷移はジェネレータに任せられます。
状態を外部へ漏らさないという意味では、これは非常に整った設計にも見えます。

しかし、ここには設計上のトレードオフがあります。
状態を内部に閉じ込められるということは、逆に言えば、その状態が通常の変数やデータ構造として直接見えにくくなるということです。
処理が単純なうちは問題になりませんが、複数のyield、条件分岐、例外処理、外部入力などが組み合わさると、現在の状態を把握するためにコードの実行順序を追いかけなければならなくなります。

ジェネレータ関数と状態管理は同じものではない

ここで整理しておきたいのが、ジェネレータと状態管理を同一視しないことです。
ジェネレータはあくまで「実行を一時停止して再開できる関数」を実現するための言語機能です。
一方、状態管理は「状態をどのように定義し、変更し、参照し、整合性を保つか」という設計上の問題です。

この2つは関連していますが、目的は異なります。
ジェネレータを使えば状態を扱えます。
しかし、状態を扱うために必ずジェネレータが必要になるわけではありません。
むしろ、状態そのものを明示的なオブジェクトとして表現したほうが、コードの意図や状態遷移を理解しやすいケースもあります。

特にWebアプリケーションのように、ユーザー操作、非同期処理、APIレスポンス、UIの更新など複数の要素が状態に影響する環境では、この区別が重要です。
処理の一時停止と状態の管理を一つの仕組みにまとめると、一見コードが簡潔になっても、状態遷移の責任範囲が曖昧になる可能性があります。

だからこそ、yieldが便利かどうかだけで判断するのではなく、「この処理で本当に実行の中断と再開が必要なのか」「単に状態を保持したいだけではないか」という観点から採用を判断する必要があります。

次の章では、こうした特徴を踏まえて、yieldやジェネレータ関数が特に有効なケースを整理します。
そのうえで、どこからが状態管理として過剰な仕組みになり得るのかを切り分けていきます。

yieldが便利なケースとジェネレータ関数が活きる場面

JavaScriptのジェネレータ関数が反復処理で活用されるイメージ

yieldは状態管理を複雑にする可能性がある一方、適切な用途では非常に合理的な選択肢です。
特に、処理対象を一度にすべてメモリへ展開する必要がなく、必要になったタイミングで値を1つずつ生成したい場合には、ジェネレータ関数の特性がそのままメリットになります。
重要なのは「yieldは避けるべき機能」と考えるのではなく、実行の一時停止と再開そのものが問題領域に適しているかで判断することです。

大量のデータを逐次処理するとき

ジェネレータが特に活きる代表例が、大量のデータを逐次処理するケースです。
例えば、非常に大きなファイルを1行ずつ読み込んだり、膨大な件数のデータを順番に変換したりする処理では、最初にすべての結果を配列へ格納するとメモリ使用量が大きくなります。

このような場合、必要なデータだけをその都度生成する遅延評価とジェネレータは相性がよいです。
呼び出し側が次の値を要求するまで処理を進めないため、入力全体をメモリ上に保持せずに済みます。
結果として、データ量が増えたときにもメモリ消費を抑えやすくなります。

ここでのポイントは、ジェネレータが「状態を管理するため」に使われているのではなく、「値を逐次的に供給するため」に使われていることです。
処理の進行位置を保持すること自体が目的ではなく、イテレーションの仕組みとして内部状態が利用されています。
この用途なら、yieldの存在意義が明確です。

無限シーケンスや遅延評価を表現するとき

ジェネレータは、理論上無限に続くシーケンスの表現にも向いています。
通常の配列では、無限個の値を事前に生成することはできません。
しかし、次の値を要求されたときだけ計算する仕組みなら、有限のメモリで無限シーケンスを扱えます。

例えば、連番、フィボナッチ数列、イベントの逐次生成などが考えられます。
もちろん、実際のアプリケーションでは無限ループを不用意に実行すれば処理が終了しなくなるため、利用側で適切に打ち切る必要があります。
それでも「必要になったら次の値を計算する」というモデルを自然に表現できるのは、ジェネレータの強みです。

遅延評価には、不要な計算を避けられるという利点もあります。
例えば100万件のデータを生成できる処理でも、利用者が最初の10件しか必要としないのであれば、残りの999,990件まで計算する必要はありません。
計算コストを需要に応じて発生させる設計です。

for…ofと組み合わせて反復処理を簡潔にする

JavaScriptのジェネレータは、for...ofなどの反復構文とも自然に組み合わせられます。
ジェネレータオブジェクトはイテラブルとして扱えるため、呼び出し側で毎回next()を直接操作しなくても、値を順番に取り出せます。

この性質は、データの生成ロジックと利用側の反復処理を分離するうえで有効です。
生成側は「次にどの値を返すか」を担当し、利用側は「返された値をどう処理するか」に集中できます。
APIとして見ても責務が比較的明確です。

特に、複雑なデータ変換を段階的に適用したい場合には、ジェネレータをパイプラインの一部として利用する設計も考えられます。
ただし、単純な配列操作で十分な処理までジェネレータに置き換える必要はありません。
map()やfilter()などで意図が明確になるなら、そちらを優先するほうが読みやすい場合もあります。

外部から処理の進行を制御したいとき

ジェネレータのもう一つの特徴は、呼び出し側が処理の進行タイミングを制御できることです。
通常の関数は呼び出した時点で処理が進みますが、ジェネレータではnext()を呼ぶまで次の処理へ進みません。
これは、外部から段階的に処理を進めたいアルゴリズムで有効です。

例えば、状態機械のように段階ごとの処理を順番に進める仕組みや、バックプレッシャーを考慮したデータ処理などでは、この性質が役立つことがあります。
消費側の準備ができてから生産側を進めるという関係を、言語機能として表現できるためです。

ただし、ここでも「制御したいもの」が何なのかを明確にする必要があります。
処理の生成タイミングを制御したいのであればジェネレータは候補になりますが、アプリケーションの共有状態を管理したいだけなら話は変わります。
状態を保持するためだけに実行停止機構を持ち込むと、設計が必要以上に複雑になる可能性があります。

yieldを採用する前に確認したい判断基準

yieldを使うかどうかは、次のような観点で判断すると整理しやすくなります。

  • 値を必要なタイミングで逐次生成する必要があるか
  • 大量のデータを一括してメモリへ保持することを避けたいか
  • 無限または非常に大きなシーケンスを遅延評価したいか
  • 呼び出し側から処理の進行タイミングを制御する必要があるか

これらの問いに明確な「はい」があるなら、ジェネレータは有力な選択肢です。
逆に、目的が「現在のユーザー状態を保持したい」「複数の処理から状態を読み書きしたい」「状態遷移をテストしやすくしたい」といったものであれば、ジェネレータ以外の設計を検討する価値があります。

つまり、yieldの評価では構文の便利さよりも、問題の性質と抽象化の一致を見るべきです。
遅延評価や逐次生成という問題に対しては強力ですが、一般的な状態管理の道具として使い始めると、別の問題を抱え込むことがあります。

この線引きを理解しておくと、「ジェネレータを使えるから使う」という設計を避けられます。
次に重要になるのは、まさにその境界です。
状態を扱う目的でyieldを導入した場合、どのような問題が発生しやすいのでしょうか。
次章では、yieldを避けるべき具体的なケースを掘り下げます。

JavaScriptでyieldを避けるべきケースとは?状態管理で注意したい問題

yieldを使った状態管理で処理の流れが複雑になるイメージ

yieldは便利な機能ですが、「使える場所」と「使うべき場所」は一致しません。
特に注意したいのが、ジェネレータ関数を一般的な状態管理の仕組みとして利用するケースです。
ジェネレータは実行位置を保持できるため、一見すると状態をカプセル化する便利な仕組みに見えます。
しかし、アプリケーションの状態管理で本当に必要なのが「実行の一時停止」なのか、それとも「状態の保持と更新」なのかを切り分けなければ、設計上の負債につながります。

状態管理では、現在の状態が何であり、どの操作によって次の状態へ遷移するのかを追跡できることが重要です。
ところがyieldを中心に処理を組み立てると、状態が明示的なデータ構造ではなく、ジェネレータ内部の実行位置やローカル変数に分散しやすくなります。
その結果、コードを読むだけでは状態の全体像を把握しにくくなることがあります。

共有状態を複数の処理から操作する場合

まず避けたいのが、複数のコンポーネントや関数から参照・更新される共有状態をジェネレータで管理するケースです。
ジェネレータは基本的に、特定の実行コンテキストを保持する仕組みです。
そのため、複数の利用者が同じ状態を操作するような設計とは、必ずしも相性がよいとはいえません。

例えば、ユーザー情報、画面の状態、フォームの入力値、APIから取得したデータなどをジェネレータ内部に保持するとします。
この場合、「現在の状態」を確認したいだけなのに、ジェネレータがどのyieldまで進んでいるかを意識する必要が出てくる可能性があります。
状態をデータとして扱うのではなく、処理の進行位置を通じて間接的に表現しているためです。

共有状態では、状態そのものを明示的に表現したほうが追跡しやすくなります。
例えば、statusやcount、selectedIdなどのプロパティを持つ状態オブジェクトを定義し、更新操作を関数として分離すれば、「何が現在の状態なのか」と「どの操作で変更されるのか」を独立して確認できます。
これはデバッグだけでなく、単体テストのしやすさにも直結します。

状態遷移を外部から明確に確認したい場合

状態機械的な処理では、現在の状態と次の状態を明示できることが重要です。
例えば「idle → loading → success」や「idle → loading → error」のように、状態遷移そのものがアプリケーションの仕様になるケースがあります。

このような場面でジェネレータを使い、yieldの位置によって状態を表現すると、仕様と実装の対応関係が分かりにくくなることがあります。
ジェネレータの何番目のyieldに到達したかを「現在の状態」とみなす設計では、状態の意味がプログラムの制御フローに埋め込まれてしまうからです。

状態遷移が重要なシステムでは、状態を文字列や列挙値、判別可能なオブジェクトなどで明示するほうが安全です。状態を独立したデータとして扱えば、ログへ出力する、テストで比較する、条件分岐する、といった操作も容易になります。状態を観測できることは、状態管理の品質に直結します。

非同期処理の流れを表現するためだけにyieldを使う場合

もう一つ注意したいのが、非同期処理を制御する目的でyieldを採用するケースです。
JavaScriptには現在、Promiseとasync/awaitという非同期処理を表現するための標準的な仕組みがあります。
そのため、単に「処理を途中で止めて、非同期処理の完了後に再開したい」という理由だけでジェネレータを導入する必然性は以前より小さくなっています。

yieldを使った非同期処理では、ジェネレータを動かす側に追加の制御ロジックが必要になる場合があります。
next()の呼び出し、Promiseの処理、エラーの伝播などを別の仕組みで組み合わせる必要があるためです。
結果として、非同期処理そのものよりも「ジェネレータをどう駆動するか」を理解しなければならない構造になりがちです。

もちろん、特定のライブラリや既存アーキテクチャでジェネレータが前提になっている場合は別です。
しかし、新規コードで単純な非同期処理を記述するのであれば、まずasync/awaitで表現できないかを検討するほうが自然です。
言語標準の抽象化を使うことで、処理の開始から完了までをコード上で追いやすくなります。

デバッグやテストで現在の状態を確認しにくい場合

状態管理において見落とせないのが、デバッグとテストです。
実装時には短く見えるコードでも、障害が発生したときに「今どの状態なのか」を確認できなければ、保守コストは急激に高くなります。

ジェネレータでは、内部の実行位置が状態の一部になります。
そのため、ある時点でジェネレータがどこまで進んでいるのかを追跡しなければならないケースがあります。
特にyieldが多数存在し、それぞれの前後で変数が更新されるような処理では、実行経路を追うためにかなりの認知負荷がかかります。

単体テストでも同様です。
状態を単純なデータとして扱う設計なら、「この入力に対して状態がこう変化した」という形でテストできます。
一方、ジェネレータの実行状態そのものに依存すると、next()を何回呼ぶか、どの値を渡すかといった制御フローまでテストケースに含まれやすくなります。
これはテスト対象の本質が状態遷移なのか、ジェネレータの実行手順なのかを曖昧にします。

チーム開発で処理の意図を共有しにくい場合

個人開発では理解できるジェネレータの使い方でも、チーム開発では別の問題が発生することがあります。
コードの保守を担当する人が、ジェネレータの実行モデルと状態遷移の両方を理解しなければならないからです。

これはyieldそのものが難しいという話ではありません。
プログラミング言語の機能は、正しく使えば強力です。
しかし、コードを読む人に余計な前提知識を要求する抽象化は、プロジェクト全体の複雑性を高める可能性があります。
特に、同じ状態を単純なオブジェクトと関数で表現できるのであれば、そちらのほうが意図を共有しやすいでしょう。

設計では、機能の表現力だけでなく、読者がコードから状態を再構成できるかも評価すべきです。
将来の自分も含め、コードを読む人が少ない手がかりで現在の状態と変更経路を理解できるなら、それは保守性の高い設計といえます。

yieldを避けるべきか判断するチェックポイント

ここまでの内容を整理すると、状態管理でyieldを採用する前に、次の点を確認すると判断しやすくなります。

  • 状態そのものと、処理の実行位置を明確に区別できているか
  • 現在の状態をデータとして簡単に観測・記録できるか
  • 状態遷移をテストケースとして独立して検証できるか
  • async/awaitや通常の関数で、より単純に表現できないか
  • チームの開発者が実行モデルを理解しなくても意図を読み取れるか

これらの条件を満たせない場合、ジェネレータを状態管理の中心に据えることは慎重に検討したほうがよいでしょう。
特に「状態を保持したい」という要件しかないのであれば、yieldは目的に対して強力すぎる道具かもしれません。

一方で、逐次的な値の生成や遅延評価など、ジェネレータ本来の強みを活かしているなら話は変わります。
重要なのはyieldを禁止することではなく、実行制御のための機能を、状態管理という別の問題に無理に流用しないことです。

では、なぜジェネレータを使った状態管理は、コードが複雑になるにつれて特に扱いにくくなるのでしょうか。
次章では、yieldによって生まれる暗黙的な状態が、可読性や保守性へどのような影響を与えるのかを、もう一段深く掘り下げます。

yieldによる暗黙的な状態がコードの可読性と保守性を下げる理由

ジェネレータ関数に隠れた状態と処理の流れを確認するイメージ

yieldを使ったコードが難しくなる原因は、構文そのものの複雑さだけではありません。
より本質的なのは、状態の一部がデータではなく実行コンテキストとして保持されることです。
通常の状態管理では、現在の状態をオブジェクトや変数として確認できます。
一方、ジェネレータでは「どのyieldまで実行したか」という情報が状態の一部になるため、コードを静的に読むだけでは現在位置を把握しにくい場合があります。

これは小規模な処理では大きな問題になりません。
yieldが2、3個程度で、各停止位置の意味も明確なら、実行の流れを追うことは容易です。
しかし、条件分岐やループ、例外処理、外部入力などが加わると状況が変わります。
処理経路の組み合わせが増えるほど、「現在どの状態にいるのか」を理解するために、実行順序を頭の中で再現しなければならなくなります。

実行位置が状態になるとコードを読み解く負担が増える

通常の状態管理では、状態を値として表現できます。
例えばstatusというプロパティがloadingなら、現在は読み込み中だと判断できます。
状態の意味がデータそのものに現れるため、コードの一部だけを確認しても理解しやすい構造です。

ところがジェネレータを状態管理に利用すると、状態の意味が実行位置に埋め込まれることがあります。
「最初のyieldの後ならA状態、次のyieldの後ならB状態」という設計です。
この場合、状態を知るためにはジェネレータのソースコードを上から読み、どの位置まで処理が進んでいるのかを推測する必要があります。

プログラムの意味がデータではなく制御フローに依存するほど、局所的な理解が難しくなります。
これはコンピューターサイエンスでいう制御状態とデータ状態の結合に近い問題です。
両者が密接に結びつくこと自体が悪いわけではありませんが、状態を独立して扱いたいシステムでは不要な依存関係になります。

next()の呼び出し回数に意味が依存しやすい

ジェネレータでは、外部からnext()を呼び出すことで処理が進みます。
そのため、状態管理に利用すると「何回next()を呼んだか」が実質的な状態になる場合があります。
例えば、1回目は初期化、2回目は入力待ち、3回目は確定処理という設計です。

この方式には、処理を段階的に進められるというメリットがあります。
しかし、呼び出し側から見ると、単純な「状態変更」の操作が「ジェネレータを決められた回数だけ進める」という手続きに変わります。
途中で条件が変わったり、例外が発生したりすると、次にnext()を呼んでよい状態なのかを判断する必要もあります。

特に保守時に問題になりやすいのが、処理の途中へ新しいyieldを追加するケースです。
既存コードが「2回目のnext()でこの状態になる」という暗黙の前提を持っていた場合、yieldを1つ追加しただけで外部の処理との対応関係が崩れる可能性があります。
インターフェースとして公開しているつもりがなくても、実質的に実行回数へ依存した契約が形成されてしまうわけです。

条件分岐が増えるほど状態遷移を追いにくくなる

ジェネレータの可読性を考えるとき、単純なサンプルだけで判断してはいけません。
実際のアプリケーションでは、ifやswitchによる条件分岐、ループ、例外処理などが組み合わされます。
ここに複数のyieldが入ると、状態遷移の経路が急速に複雑になります。

例えば、ある条件では最初のyieldへ進み、別の条件では2番目のyieldを経由せずに3番目へ到達する、といった構造です。
このとき、コード上には複数の実行経路が存在します。
さらに、外部から渡された値によって次のyieldが変わるなら、現在の状態を判断するために入力値と過去の実行履歴まで考慮しなければなりません。

これは状態機械として考えると分かりやすい問題です。
状態と遷移が明示されていれば、どの状態からどこへ移動できるかを整理できます。
しかし、遷移がジェネレータの制御フローに埋め込まれていると、状態機械の構造をコードから読み取る作業が必要になります。
状態が増えるほど、その差は大きくなります。

デバッグ時に「現在の状態」を観測しにくい

可読性の問題は、そのままデバッグの難しさにもつながります。
障害が発生したとき、開発者が最初に知りたい情報の一つは「その時点で何が起きていたのか」です。
通常の状態オブジェクトなら、ログに状態を出力するだけで状況を把握できる場合があります。

一方、ジェネレータの実行位置は、一般的なデータプロパティのように扱えるものではありません。
内部状態を直接観測するためには、追加のログやデバッグ操作が必要になることがあります。
その結果、障害調査のためにソースコードを追跡し、どの条件を通ってどのyieldで停止したのかを再構成する作業が発生します。

もちろん、適切なログを設計すれば対応できます。
しかし、それは裏を返せば、状態が自然に観測できる設計ではないため、観測のための仕組みを追加しているともいえます。
運用時のデバッグまで考えるなら、状態を明示的なデータとして保持する設計には大きな価値があります。

テストが実装の手順に引っ張られやすい

テストコードへの影響も無視できません。
状態管理のテストでは、本来「ある入力に対して状態がどう変化するか」を検証できれば十分なはずです。
しかし、ジェネレータを中心に設計すると、「何回next()を呼び出すか」「そのとき何が返るか」という実装上の手順までテスト対象になりやすくなります。

もちろん、ジェネレータそのものをテストするのであれば、この方法は合理的です。
問題は、アプリケーションの状態遷移をテストしたいのに、ジェネレータの操作手順までテストしなければならなくなる場合です。
実装を少し変更しただけでテストが大量に壊れるなら、テストが仕様ではなく実装詳細へ依存している可能性があります。

保守性の高いテストでは、できるだけ「何を保証したいのか」を直接表現したいものです。
状態管理なら、入力、現在状態、操作、次の状態という関係を明示できる構造のほうが、テストの意図も読み取りやすくなります。

暗黙的な状態を減らすことが保守性につながる

ここまでの問題を一つにまとめると、yieldが悪いのではなく、状態の意味が実行位置に隠れてしまうことが問題です。
ジェネレータが「次の値を生成する」という目的で使われているなら、その実行位置は自然な内部状態です。
しかし、「ユーザーがログインしている」「データを読み込み中である」「フォームが送信済みである」といったアプリケーション状態まで実行位置で表現すると、抽象化の境界がずれてきます。

状態を明示的なデータとして表現すれば、読み取り、更新、比較、保存、ログ出力、テストといった操作を独立して考えられます。
これは単なるコードの好みではなく、状態の観測可能性と変更可能性を高める設計上の利点です。

したがって、yieldを使ったコードを見たときは、「このジェネレータは何を生成しているのか?」と同時に、「このジェネレータの実行位置を、アプリケーションの状態として扱っていないか?」と問いかけるのが有効です。
後者に当てはまるなら、状態を別のデータ構造として切り出す余地があります。

では、ジェネレータを使わずに状態を明示的に管理するには、どのような設計が考えられるのでしょうか。
次章からは、クロージャや状態オブジェクトなどを使い、状態と処理の流れを分離する具体的な代替パターンを見ていきます。

状態管理を安全にする代替パターン1:クロージャで状態を明示的に管理する

JavaScriptのクロージャで状態をカプセル化して管理するイメージ

yieldを状態管理に利用する必要がないのであれば、まず検討したいのがクロージャです。
クロージャは、関数と、その関数が参照している外側のスコープを組み合わせた仕組みです。
JavaScriptでは関数が作られた時点のレキシカルスコープを保持できるため、外部から直接触れさせたくない状態を内部変数として閉じ込め、その状態を操作する関数だけを公開できます。

これはジェネレータと同じく「状態を外部から隠す」ことができますが、状態と実行位置を分離できる点が重要です。
クロージャでは、状態そのものは通常の変数として存在します。
関数を何回呼び出したかや、どのyieldまで進んだかを状態の意味として解釈する必要はありません。
現在値を保持する変数と、その値を変更する操作が明示されるため、設計意図を追いやすくなります。

クロージャで状態をカプセル化する基本的な考え方

クロージャを状態管理へ利用する基本形は、「内部状態を変数として持ち、外部には必要な操作だけを関数として公開する」というものです。
例えばカウンターを考えてみましょう。
外部から直接カウンターの値を書き換えられるようにするのではなく、取得と加算という操作だけを公開します。

function createCounter(initialValue = 0) {
  let count = initialValue;

  return {
    get() {
      return count;
    },
    increment() {
      count += 1;
      return count;
    }
  };
}

この例では、countが関数の外部から直接参照できません。
しかし、get()やincrement()はcountを参照できます。
これらの関数がcountを保持したまま利用できるのがクロージャの特徴です。

重要なのは、ここで保持されている状態が「ジェネレータの実行位置」ではないことです。
countという明示的なデータがあり、それを変更する操作も明示されています。
コードを読む側は、状態がどこにあるのか、どの操作によって変化するのかを比較的容易に追跡できます。

状態を直接公開せず、不正な変更を防ぐ

状態管理でクロージャが便利なのは、単に変数を隠せるからではありません。
状態を変更できる経路を限定できることに意味があります。

例えば、アプリケーションの状態として「未開始」「処理中」「完了」のような段階を持たせる場合、外部コードから自由に値を代入できる設計にすると、想定外の状態へ変更される可能性があります。
クロージャを使えば、状態変更を担当する関数だけを公開し、許可された遷移だけを実行する構造にできます。

この考え方はカプセル化そのものです。
内部データを隠し、公開された操作を通じて状態を変更します。
オブジェクト指向でいうprivateな状態と公開メソッドに近い発想ですが、JavaScriptではクロージャだけでも比較的軽量に実現できます。

特に小規模から中規模の状態管理では、このシンプルさが大きなメリットになります。
大掛かりな状態管理ライブラリを導入するほどではないものの、グローバル変数として状態を持つのは避けたい。
そんな場面で有効です。

状態の更新ルールを関数に集約する

クロージャを使う場合、さらに重要なのが「状態を変更する処理を一箇所へ集約する」ことです。
状態を持っているだけでは、保守性は自動的には向上しません。
複数の関数がそれぞれ異なるルールで状態を書き換えると、結局どこで何が起きるのか分かりにくくなります。

例えば残高を管理する処理なら、「入金は正の値だけ受け付ける」「出金によって残高がマイナスにならないようにする」といったルールを状態変更関数の中へ集約できます。
外部のコードが内部変数を直接変更できなければ、これらの制約を迂回する経路も減らせます。

この設計の利点は、状態と不変条件を近い場所へ置けることです。
状態を正しく保つための条件が複数箇所へ散らばらないため、仕様変更にも対応しやすくなります。
状態を変更する入口を限定することは、バグの発生経路を減らすことにもつながります。

クロージャとジェネレータの違いを整理する

クロージャとジェネレータは、どちらも内部に情報を保持できるため、一見すると似た用途に使えそうです。
しかし、両者の抽象化は異なります。

観点 クロージャ ジェネレータ
主な目的 状態のカプセル化 処理の一時停止と値の逐次生成
状態の表現 変数やオブジェクト 実行位置とローカル状態
操作 公開した関数を呼び出す next()で処理を進める
向いている用途 状態管理、状態変更の制御 遅延評価、反復処理

もちろん、この表の境界は絶対的なものではありません。
クロージャで反復処理を実装することもできますし、ジェネレータで状態を保持することも可能です。
ただし、設計時には「何を第一目的とするか」を基準に選ぶことが重要です。

状態を安全に保持し、変更経路を制御することが目的なら、クロージャは非常に素直な選択肢です。
一方、値を必要なタイミングで生成したり、処理を停止して再開したりすることが目的なら、ジェネレータのほうが自然です。

クロージャにも注意点がある

とはいえ、クロージャを使えば常に安全というわけではありません。
内部状態を隠せる反面、状態が長期間保持されることや、どの関数がその状態を変更するのかが分かりにくくなる可能性があります。

特に巨大な状態オブジェクトをクロージャへ閉じ込めると、外部から状態を確認する手段が不足することがあります。
デバッグやテストのために状態を取得するAPIが必要になる場合もあるでしょう。
また、クロージャを大量に生成すると、それぞれが独立した状態を持つため、インスタンス数によっては設計を見直す必要があります。

したがって、クロージャを採用するときも「何を隠し、何を公開するか」を明確にすることが重要です。
状態を隠すこと自体が目的ではなく、不正な変更を防ぎながら、必要な状態を観測できる設計にすることが本質です。

例えば読み取り専用のgetState()を用意し、更新操作を限定する方法があります。
これなら内部状態を直接変更させずに、テストやログ出力では現在の状態を確認できます。
完全に隠すのではなく、必要な情報だけを安全に公開するという考え方です。

クロージャは、yieldのような実行制御機構を使わずに状態を保持できるため、状態管理を目的とするコードでは非常に扱いやすい選択肢です。
特に状態の所有者と変更ルールを明確にしたい場合、その構造はシンプルで説明しやすいものになります。

ただし、状態が複雑になれば、クロージャだけで管理するのが最適とは限りません。
状態そのものをデータ構造として明示し、状態遷移を関数として整理したほうが適切なケースもあります。
次章では、状態オブジェクトと関数を組み合わせ、状態遷移をさらに明示的に表現するパターンを見ていきます。

状態管理を安全にする代替パターン2:状態オブジェクトと関数で遷移を明確にする

状態オブジェクトと関数でJavaScriptの状態遷移を管理するイメージ

クロージャで状態をカプセル化する方法はシンプルで有効ですが、状態の種類や遷移が増えてくると、状態そのものをデータとして明示したほうが理解しやすいケースがあります。
そこで有力になるのが、現在の状態をオブジェクトとして表現し、その状態を受け取って次の状態を返す関数を用意する方法です。

この設計では、ジェネレータの実行位置に状態の意味を持たせません。
「現在は何の状態なのか」をデータとして表し、「この操作を実行すると次にどの状態になるのか」を関数として定義します。
状態と制御フローを分離できるため、コードを読む側が実行履歴を推測しなくても、状態遷移のルールを確認しやすくなります。

現在の状態をデータとして表現する

まず重要なのは、状態を通常のJavaScriptオブジェクトとして表すことです。
例えばデータ取得処理なら、idle、loading、success、errorといった状態を明示できます。

const state = {
  status: "idle",
  data: null,
  error: null
};

この構造なら、現在の状態を確認するためにジェネレータの実行位置を追跡する必要がありません。
state.statusを見れば、現在どの段階にあるのかが直接分かります。
データの内容も同じオブジェクトに含められるため、「状態」と「状態に付随するデータ」の関係も明確です。

さらに、状態をオブジェクトとして扱うことで、ログへの出力やテストでの比較も容易になります。
例えばエラーが発生した時点の状態をそのまま記録したり、ある操作の前後で状態がどう変わったかを比較したりできます。
これは運用時のデバッグにも有利です。

状態を変更する処理を関数へ分離する

状態を明示するだけでは、状態管理の設計としてはまだ不十分です。
重要なのは、その状態がどのようなルールで変化するのかを明確にすることです。
そこで、現在の状態を引数として受け取り、新しい状態を返す関数を用意します。

function startLoading(state) {
  if (state.status !== "idle") {
    return state;
  }

  return {
    ...state,
    status: "loading",
    error: null
  };
}

この関数では、「idleのときだけloadingへ遷移できる」というルールがコード上で明確になっています。
ジェネレータの何番目のyieldに到達したかを考える必要はありません。
入力となる状態と、出力される状態を確認すれば、関数の責務を理解できます。

このような関数を状態遷移ごとに整理していけば、状態管理のロジックを小さな単位へ分割できます。
各関数が状態を変更する責務を明確に持つため、複雑な処理を一つのジェネレータへ集約するよりも、テスト対象を限定しやすくなります。

状態遷移を明示すると仕様と実装を対応させやすい

状態管理が複雑になるほど、「どの状態からどの状態へ遷移できるのか」を把握することが重要になります。
例えば、データ取得処理なら次のような状態遷移を考えられます。

idle → loading → success
             ↘ error

このような構造をコードでも意識しておけば、仕様書や設計図と実装の対応関係を保ちやすくなります。
loadingから直接idleへ戻すのか、errorから再試行できるのか、といったルールも関数単位で定義できます。

ここで重要なのは、状態遷移を「プログラムがたまたまそう動くもの」にしないことです。
状態そのものと遷移ルールを明示すれば、設計上の制約をコードへ反映できます。
これはバグを完全になくす魔法ではありませんが、許されていない遷移を見つけやすくするという意味で有効です。

一方、ジェネレータでは処理の流れそのものが状態遷移を兼ねることがあります。
コードが短くなる場合もありますが、状態の仕様を確認するには制御フロー全体を追う必要があります。
状態が増えたときにどちらが読みやすいかを考えると、データと遷移を分離する設計の価値が見えてきます。

状態更新を純粋関数に近づけるメリット

状態オブジェクトを扱う関数を設計するとき、可能であれば「入力された状態を直接変更せず、新しい状態を返す」形にすると、さらに扱いやすくなります。
いわゆるイミュータブルな更新です。

例えば、関数へ現在の状態とイベントを渡し、その結果として次の状態を返す構造です。
このモデルでは、関数の外側に隠れた可変状態へ依存しにくくなるため、同じ入力から同じ結果が得られることを確認しやすくなります。

function reduceState(state, event) {
  if (state.status === "idle" && event.type === "START") {
    return { ...state, status: "loading" };
  }

  if (state.status === "loading" && event.type === "SUCCESS") {
    return { ...state, status: "success", data: event.data };
  }

  return state;
}

この考え方は、状態管理を「状態とイベントから次の状態を計算する問題」として扱う方法です。
ジェネレータのように内部実行状態を保持する必要がないため、処理の結果を入力と出力の関係として捉えられます。

この形式にはテスト上のメリットもあります。
例えば「idle状態でSTARTイベントを受け取ったらloadingになる」というルールを、そのまま一つのテストケースとして表現できます。
テストのためにnext()を何度も呼び出す必要はありません。
仕様上の状態遷移を直接検証できるわけです。

状態と副作用を分離しておく

ただし、状態遷移を関数へまとめるときに注意したいのが、副作用との分離です。
APIへのアクセス、DOMの更新、ログ出力、タイマーなどを状態更新関数へすべて詰め込むと、せっかく状態を明示しても関数の責務が大きくなります。

理想的には、「現在の状態から次の状態を決める処理」と「外部システムへ作用する処理」を可能な範囲で分けます。
例えばAPI通信そのものは別の関数が担当し、通信が成功したらSUCCESSというイベントを状態管理側へ渡す設計です。

この分離によって、状態遷移のロジックを外部環境から独立してテストしやすくなります。
また、通信方式やUIフレームワークを変更した場合でも、状態管理の中核部分まで大きく書き換えずに済む可能性があります。

状態オブジェクト方式にも限界はある

状態オブジェクトと関数による設計は強力ですが、状態が非常に単純な処理にまで適用すると、かえってコードが冗長になる場合があります。
単純なカウンターや一時的なローカル状態なら、通常の変数やクロージャのほうが自然でしょう。

また、状態の種類が増えすぎると、状態オブジェクトの設計そのものが複雑になります。
その場合はTypeScriptの判別可能なユニオン型などを利用し、状態ごとに必要なデータ構造を明確にする方法も有効です。
JavaScriptだけであっても、statusの値を基準に処理を分岐させるなど、状態の構造を一貫させることが重要です。

つまり、このパターンの目的は「何でも状態オブジェクトにする」ことではありません。
状態を実行位置から切り離し、必要な場合にだけ明示的なデータとしてモデル化することです。

ジェネレータが得意なのは、処理を停止して再開しながら値を生成することです。
一方、状態オブジェクトと関数は、状態そのものと遷移ルールを明示することに向いています。
この違いを理解しておけば、yieldを使わなくても状態管理を十分に表現できます。

さらに、実際のWebアプリケーションでは状態管理と非同期処理がセットになることも珍しくありません。
その場合、「処理を止めて再開する」ためにジェネレータを使うのではなく、JavaScript標準のPromiseとasync/awaitで非同期処理を表現するほうが自然なケースがあります。
次章では、この観点からasync/awaitを使った状態管理との組み合わせを見ていきます。

状態管理を安全にする代替パターン3:async/awaitで非同期処理を分かりやすく書く

JavaScriptのasync awaitで非同期処理の流れを明示するイメージ

JavaScriptでyieldを使いたくなる理由の一つに、「処理を途中で止めて、非同期処理が終わったら続きを実行したい」という要求があります。
特に古いコードやジェネレータを利用した非同期処理では、yieldによってPromiseの完了を待つような構造を作ることがあります。
しかし、現在のJavaScriptでは、非同期処理を表現するための標準的な手段としてasync/awaitが用意されています。

async/awaitの重要な点は、非同期処理の待機とアプリケーションの状態管理を分離しやすいことです。
awaitは処理を一時的に待機させますが、そのためにジェネレータオブジェクトを外部からnext()で駆動する必要はありません。
コード上の処理順序も上から下へ追いやすく、非同期処理を含むロジックを通常の逐次処理に近い形で記述できます。

yieldを非同期処理に使う設計が複雑になりやすい理由

ジェネレータを非同期処理に利用する場合、ジェネレータ自身と、それを実行する側の仕組みを組み合わせる必要があります。
yieldされた値がPromiseなら、その完了を待って次のnext()を呼び出す、といった制御です。

この方式は仕組みとして成立しますが、コードの責務が増えます。
ジェネレータは処理の途中で停止する役割を持ち、それを外側のランナーが再開させる役割を担います。
エラーが発生した場合も、どこで捕捉し、どのようにジェネレータへ戻すのかを考える必要があります。

一方、async関数では非同期処理の待機が言語機能として直接表現できます。
非同期処理を実行し、その結果をawaitで受け取り、次の処理へ進むという流れが明確です。
特別なジェネレータランナーを用意する必要がないため、コードの構造も比較的単純になります。

async/awaitで非同期処理と状態更新を分離する

状態管理と非同期処理を組み合わせる場合は、「通信を実行する処理」と「状態を更新する処理」を分けると設計しやすくなります。
例えば、データ取得を行う関数と、その結果に応じて状態を更新する処理を別々に考えます。

async function loadData() {
  try {
    const response = await fetch("/api/data");
    const data = await response.json();
    return { status: "success", data, error: null };
  } catch (error) {
    return { status: "error", data: null, error };
  }
}

この例では、awaitが非同期処理の完了を待つ役割を担っています。
一方、戻り値はstatus、data、errorという状態を表すデータです。
つまり、「処理を待つ仕組み」と「結果を状態として表現する仕組み」が別になっています。

この分離が重要です。
yieldを状態管理へ利用すると、処理の一時停止そのものが状態表現の一部になりやすいのに対して、async/awaitと状態オブジェクトを組み合わせれば、非同期処理と状態遷移をそれぞれ独立した概念として扱えます。

awaitは処理の順序をコード上で追いやすくする

async/awaitの大きな利点は、非同期処理の依存関係をコードの記述順序に近い形で表現できることです。
例えば、「認証情報を取得する」「その情報を使ってAPIを呼ぶ」「結果を加工する」という処理があるとします。
これらをawaitで順番に記述すると、処理の依存関係がコード上で自然に表れます。

これは可読性だけの問題ではありません。
保守時には、ある処理がどの結果に依存しているのかを把握できることが重要です。
ジェネレータを使った独自の非同期制御では、yieldとランナーの関係まで追跡しなければならない場合がありますが、awaitなら非同期処理を待っている箇所が構文として明確です。

もちろん、async/awaitも万能ではありません。
並列に実行できる処理をすべて順番にawaitすると、不要に処理時間を延ばすことがあります。
独立した複数のPromiseを同時に開始し、Promise.all()などで結果をまとめるほうが適切なケースもあります。

したがって、awaitを使えば自動的に最適化されるわけではありません。
非同期処理の依存関係を分析し、直列実行すべき処理と並列実行できる処理を区別することが重要です。

非同期処理中の状態遷移を明示する

Webアプリケーションでは、API通信そのものよりも、「通信中に画面がどの状態になるか」のほうが重要なことがあります。
例えば、リクエスト開始時にloadingへ移行し、成功したらsuccess、失敗したらerrorへ移行するという設計です。

この場合、非同期処理と状態遷移を明確に分けると理解しやすくなります。
概念的には次のような流れです。

  1. リクエスト開始前の状態を確認する
  2. loading状態へ更新する
  3. awaitでAPI処理の完了を待つ
  4. 成功ならsuccess、失敗ならerrorへ更新する

ここでawaitが担当するのは3番目だけです。
状態そのものを保持したり、状態間の遷移ルールを定義したりする役割は持たせません。
この責務分離によって、「非同期処理がどこで待たれているか」と「アプリケーションがどの状態へ遷移するか」を別々に考えられます。

この設計は、先ほど紹介した状態オブジェクトと特に相性がよいものです。
状態を明示的なデータとして持ち、async関数で非同期処理を制御する。
これだけでも、ジェネレータを状態管理の中心に置く必要性はかなり減ります。

エラー処理もasync/awaitの流れに組み込みやすい

非同期処理では、正常系だけでなくエラー時の状態も重要です。
API通信に失敗した場合、画面へエラーを表示するのか、リトライするのか、ログへ記録するのかなど、複数の判断が必要になります。

async/awaitでは、try/catchを使って非同期処理のエラーを通常の例外処理に近い形で扱えます。
これによって、成功時と失敗時の処理を同じ関数の中で整理できます。
ジェネレータと独自ランナーを組み合わせる方式と比較すると、エラーの伝播経路を理解するために必要な概念が少なくなります。

ただし、catchですべてのエラーを一括処理すればよいわけではありません。
ネットワークエラー、認証エラー、入力エラーなど、意味の異なる失敗を同じ状態として扱うと、後から分岐が複雑になります。
エラーの種類と状態モデルを整理し、必要な情報を状態へ反映することが重要です。

async/awaitでも状態と制御フローを混同しない

async/awaitを採用したからといって、状態管理の問題が自動的に解決するわけではありません。
ここでも基本原則は同じです。
非同期処理を待つことと、アプリケーションの状態を管理することは別の問題です。

例えば、awaitの前後でローカル変数を大量に変更し、その値によって状態を暗黙的に表現すると、ジェネレータで起きた問題と似た構造になる可能性があります。
yieldをawaitへ置き換えるだけでは、本質的な設計改善にはなりません。

重要なのは、状態を明示的に定義し、状態遷移を追跡できるようにしたうえで、非同期処理の待機にはasync/awaitを使うことです。
適切な抽象化をそれぞれの問題へ割り当てる。
これが設計上のポイントです。

ジェネレータは逐次的な値の生成や遅延評価には優れています。
一方、通常のWebアプリケーションで発生するAPI通信やユーザー操作に伴う非同期処理では、async/awaitのほうが意図を直接表現できるケースが多いでしょう。

ここまでで、クロージャ、状態オブジェクト、async/awaitという三つの代替パターンを見てきました。
次は、これらを実際にどう使い分ければよいのかが問題になります。
次章では、yieldと各代替パターンを比較し、用途に応じた選択基準を整理します。

yieldと代替パターンを比較して選ぶ基準

JavaScriptのyieldと状態管理の代替パターンを比較するイメージ

ここまで、yieldを使ったジェネレータの特徴と、状態管理を明示的に行うためのクロージャ、状態オブジェクト、そして非同期処理を扱うasync/awaitを見てきました。
ここで重要なのは、「yieldは危険だから使わない」という単純な結論ではありません。
プログラミングでは、ある機能が悪いのではなく、問題の性質と抽象化の選択が一致しているかが重要です。

yieldは値を段階的に生成したり、処理の途中で実行を一時停止して外部から再開したりするための機能です。
そのため、処理そのものが「何度も再開される計算」や「逐次的な値の生成」として自然にモデル化できるのであれば、ジェネレータは非常に強力です。
一方で、単に状態を保持したい、API通信を待ちたい、画面の状態を管理したい、といった目的であれば、別の抽象化のほうがコードの意図を明確にできます。

まず「何を管理したいのか」を考える

yieldを使うかどうかを決める前に、対象となる処理を三つの観点に分解すると判断しやすくなります。
それは「値の生成」「状態の管理」「非同期処理」のどれが主目的なのかという点です。

  • 値を必要なタイミングで順番に生成したいなら、ジェネレータが適しています
  • オブジェクトの内部状態を保持し、操作によって状態を変化させたいなら、クロージャや状態オブジェクトが適しています
  • Promiseの完了を待ちながら処理を順番に進めたいなら、async/awaitが適しています

この区別を曖昧にすると、「途中で処理を止められるから」という理由だけでyieldを採用してしまいます。
しかし、「止められる」という性質だけを取り出せば、ジェネレータはかなり低レベルな制御機構です。
必要なのが単なる非同期処理の待機ならawaitのほうが直接的ですし、必要なのが状態の保持なら、状態そのものをデータとして表現したほうが追跡しやすくなります。

yieldを選んでよいケース

では、どのような場合ならyieldを積極的に選んでもよいのでしょうか。
代表的なのは、ジェネレータが提供する「反復可能性」そのものに価値があるケースです。

例えば、大量のデータを一度にメモリへ展開せず、必要になった分だけ順番に生成したい場合があります。
ファイルの行を順番に処理する、木構造を深さ優先で探索する、無限に続く数列から必要な値だけ取り出す、といった処理です。
この場合、ジェネレータの「次の値が必要になるまで計算しない」という性質が問題とよく対応しています。

また、呼び出し側が反復処理を制御したいケースもあります。
for...ofなどの反復処理と組み合わせれば、ジェネレータはJavaScriptのイテレータプロトコルに自然に接続できます。
このような用途では、yieldは状態管理のための特殊な仕組みではなく、「値を生成するための自然なAPI」として機能します。

ここで重要なのは、ジェネレータの実行位置が副次的に状態になるのではなく、実行位置そのものが処理モデルの一部になっていることです。
この違いはかなり大きいものです。

状態を管理するなら状態をデータとして表現する

一方、「現在ログインしているか」「フォームが送信中か」「処理が完了したか」といったアプリケーションの状態を管理する場合は、状態を明示的なデータとして表現するほうが適しています。

状態管理では、現在値を確認したうえで次の状態を決定するという考え方が基本になります。
例えばidle、loading、success、errorのような状態を持つなら、その値を直接確認できることに大きな意味があります。
デバッガーで確認しやすく、ログにも出力しやすく、テストでも「この入力に対してこの状態になる」という形で検証できます。

ジェネレータの場合、現在の意味を理解するために「何回next()されたか」「どのyieldの直後なのか」「どの分岐を通過したのか」といった実行履歴を追う必要が出ることがあります。
状態を明示的なデータにすれば、この情報の一部を現在の状態値として直接観測できます。

これは可読性だけではなく、システムの検証可能性にも関係します。
状態がデータとして表現されていれば、状態遷移を単独の関数としてテストすることも容易です。
外部サービスや時間に依存しない純粋な変換として設計できれば、テストの実行も高速になります。

非同期処理ならasync/awaitを第一候補にする

API通信、データベースアクセス、ファイル読み込みなど、Promiseの完了を待つことが主目的なら、まずasync/awaitを検討するのが自然です。
これは単に記述量が少ないからではありません。
JavaScriptの非同期処理モデルに対して、現在の言語仕様が提供している標準的な構文だからです。

yieldの場合、ジェネレータを生成してから外部コードがnext()を呼び、場合によってはPromiseの結果を受け取って次の処理へ進めるという制御が必要になります。
独自のランナーやフレームワークを組み合わせれば高度な制御もできますが、その分だけ理解すべき仕組みが増えます。

一方、awaitでは「このPromiseの完了を待ってから次へ進む」という意図がコードから直接読み取れます。
エラーもtry/catchで扱いやすく、処理の依存関係を追跡しやすい構造です。
したがって、単純な非同期ワークフローを実装するためだけにジェネレータを導入する合理性は、現代のJavaScriptでは低くなっています。

ただし、async/awaitを採用すれば競合状態まで解決するわけではありません。
例えば、同じ画面から短時間に二つのリクエストを開始し、後から開始したリクエストより先に古いリクエストが完了することがあります。
その結果、古いレスポンスで新しい状態を上書きしてしまう可能性があります。

このような問題は非同期制御と状態管理の両方に関係します。
必要に応じてリクエストID、キャンセル処理、AbortController、最新リクエストだけを採用するためのガードなどを設計する必要があります。
構文をawaitへ変更するだけで状態管理が安全になるわけではない、という点は押さえておきたいところです。

チーム開発では「読める人の数」も判断材料にする

技術選定では、機能的に実現可能かだけでなく、チームのメンバーがそのコードをどれだけ容易に理解できるかも重要です。
ジェネレータはJavaScriptの標準機能ですが、すべての開発者がジェネレータの実行コンテキストやイテレータプロトコルに精通しているとは限りません。

もちろん、高度な機能を使うこと自体が悪いわけではありません。
専門性が必要な処理では、適切な抽象化を選択することに価値があります。
ただし、単純な状態管理のために複雑な制御フローを導入しているのであれば、設計上のコストを正当化できるか検討すべきです。

特に長期間保守されるコードでは、現在の実装者だけでなく、半年後や数年後に読む開発者にとって理解しやすいかが重要になります。
コードの局所的な短さより、意図を復元するための認知コストが低いかを見るべきです。

判断に迷ったときの実践的な基準

最終的には、次のような問いを順番に当ててみると判断しやすくなります。

  1. 管理したいものは「状態」なのか、それとも「生成される値」なのか?
  2. 処理を止めること自体に意味があるのか、それとも単に非同期処理の完了を待ちたいだけなのか?
  3. 現在の状態を、変数やオブジェクトとして直接観測できる必要があるか?
  4. 状態遷移を単体テストとして独立して検証したいか?
  5. ジェネレータを駆動するための追加機構を導入する価値が本当にあるか?

これらの問いに対して「値を段階的に生成する」が中心ならyield、「状態を保持して操作する」が中心ならクロージャや状態オブジェクト、「非同期処理の完了を待つ」が中心ならasync/awaitという整理ができます。

つまり、yieldを避けるべきかどうかは、構文単体で判断する問題ではありません。
問題の構造に対して、最も直接的な抽象化を選ぶことが本質です。
ジェネレータが問題を自然に表現しているなら、無理に別の方法へ置き換える必要はありません。
逆に、状態や非同期処理を表現するためだけにジェネレータを使っているなら、より明示的なパターンへ移行する価値があります。

この基準を持っておけば、「yieldは使わない」という極端なルールではなく、「この処理にはなぜこの抽象化が適しているのか」という設計判断ができるようになります。
次章では、実装へ落とし込む際に確認しておきたい状態管理の設計ポイントと、これらの状態遷移をどのようにテストすればよいのかを整理します。

実装時に確認したい状態管理の設計ポイントとテスト方法

JavaScriptの状態管理コードをテストして品質を確認するイメージ

ここまで見てきたように、yieldを避けるべきかどうかは、機能そのものの良し悪しではなく、状態管理という問題に対して適切な抽象化を選べているかで判断することが重要です。
実装段階では、さらに一歩進んで「その状態は何を意味するのか」「どの操作で変化するのか」「異常系ではどうなるのか」を明確にしておく必要があります。
状態管理はコードを書き始める前の設計が、そのまま保守性に直結しやすい領域です。

特に注意したいのは、状態を変数として持っているだけで状態管理が明示的になったとは限らない点です。
複数の関数が同じ変数を書き換えたり、特定の関数を呼び出した順番によって意味が変わったりすると、表面的には単純でも実際には暗黙的な状態機械になっています。
yieldを取り除いたとしても、この構造が残っていれば問題の本質は解決していません。

状態の種類と意味を最初に定義する

最初に確認したいのは、状態が何を表しているのかです。
例えばデータ取得処理なら、単純にdataがあるかどうかだけを見るのではなく、「まだ開始していない」「取得中」「取得に成功した」「取得に失敗した」といった意味を分けて考えます。

このとき、状態の組み合わせによって矛盾した値が作れないかも重要です。
例えばstatusがidleなのにerrorが残っている、successなのに必要なデータが存在しない、といった状態です。
プロパティを増やすほど自由度は高くなりますが、同時に不正な組み合わせも増えます。

可能であれば、状態を有限個の明確なケースとして整理します。
これは有限状態機械の考え方にも近く、現在の状態と発生したイベントから次の状態を決める構造です。
状態の意味が明確なら、実装者以外の人でも仕様を読み取りやすくなります。

状態を変更できる場所を限定する

次に重要なのが、状態をどこから変更できるようにするかです。
状態を複数の場所から自由に書き換えられる設計は、短いコードでは便利に見えます。
しかし、規模が大きくなると「この値を変更しているのはどこか」という追跡が難しくなります。

そのため、状態更新を特定の関数やモジュールに集約する方法が有効です。
例えばイベントを受け取って次の状態を返す関数を用意し、UIやAPI処理から直接状態を書き換えないようにします。
これによって状態遷移のルールを一か所に集められます。

もちろん、すべての状態変更を一つの巨大な関数へ押し込めばよいわけではありません。
巨大な状態管理関数は別の複雑性を生みます。
重要なのは、変更経路を予測可能にすることです。
どの操作がどの状態を変更するのかが明確であれば、デバッグもしやすくなります。

副作用と状態遷移を分離する

状態管理をテストしやすくするうえで特に効果が高いのが、副作用と状態遷移の分離です。
HTTP通信、DOM操作、タイマー、ストレージへの書き込みなどは外部環境に依存するため、純粋な状態遷移とは性質が異なります。

例えば「リクエストが成功した」というイベントを受け取ったらsuccess状態へ移行する処理と、「実際にHTTPリクエストを送信する」処理を同じ関数へ詰め込む必要はありません。
前者は入力と出力が明確な関数として切り出し、後者は外部サービスとの接続部分として分離できます。

この構造にすると、状態遷移のテストではネットワーク接続を必要としません。
つまり、テストの対象を「通信が成功したときに正しい状態になるか」という純粋なロジックへ限定できます。
副作用については別途、少数の統合テストなどで確認すればよいわけです。

状態遷移をテーブルにして考える

状態が複数ある場合は、実装前に遷移を整理しておくと効果的です。
例えば次のような表にすると、実装すべきケースと禁止すべきケースを明確にできます。

現在の状態 イベント 次の状態
idle START loading
loading SUCCESS success
loading FAILURE error
success RESET idle

この表の価値は、単に仕様書として読みやすいことだけではありません。
テストケースをそのまま導出できる点にあります。
「このイベントが発生したら次にどの状態になるべきか」という条件が明確なので、正常系だけでなく不正な遷移も検討できます。

例えばidle状態でSUCCESSイベントが発生した場合をどう扱うのか、success状態で再びFAILUREが発生した場合は無視するのか、エラー状態から再試行できるのか、といったケースです。
こうした境界条件こそ、実際のバグにつながりやすい部分です。

テストでは「next()の回数」ではなく状態を検証する

yieldを状態管理に利用しているコードをテストする場合、ジェネレータへ何回next()を呼ぶかを中心にテストしてしまうことがあります。
しかし、これは実装詳細に強く依存したテストになりやすい問題があります。

例えば内部のジェネレータ構造を変更してyieldの数が変わっただけで、ビジネス上の仕様は変わっていないのにテストが壊れる可能性があります。
これはテストが「何を保証するべきか」ではなく「現在の実装がどう動いているか」を検証している状態です。

状態管理のテストでは、できるだけ外部から観測できる意味を検証します。
つまり、「開始イベントを渡したらloadingになる」「成功イベントを渡したらデータを保持したsuccessになる」「失敗イベントを渡したらエラー状態になる」といった形です。

この考え方なら、内部実装をジェネレータから状態オブジェクトへ変更したとしても、仕様が変わっていなければテストの意図を維持できます。
実装ではなく振る舞いをテストするという原則です。

非同期処理では競合状態もテストする

async/awaitを使ったコードでは、通常の成功・失敗だけでなく、複数の非同期処理が同時に進行するケースにも注意が必要です。
例えばユーザーが検索欄へ短時間に異なる文字列を入力すると、複数のAPIリクエストが並行して発生することがあります。

この場合、後から開始したリクエストが先に完了するとは限りません。
古いリクエストのレスポンスが新しい検索結果を上書きすると、ユーザーには一見ランダムな不具合として見えます。

そのため、非同期処理のテストでは、リクエストの完了順序を意図的に入れ替えても正しい状態になるかを確認することが重要です。
必要ならリクエスト識別子を状態へ持たせ、現在有効なリクエスト以外の結果を無視する設計にします。
キャンセル可能な処理ではAbortControllerを利用する方法もあります。

境界条件と不正な操作を先に考える

状態管理の品質を決めるのは、正常系よりも境界条件であることが少なくありません。
実装時には、「本来起こらないはず」と考えている操作についても、実際に起きた場合の挙動を決めておきます。

  • 同じ開始イベントが二度送られた場合
  • 処理中にリセットされた場合
  • 成功した後に古いエラーが返ってきた場合
  • 非同期処理がキャンセルされた場合
  • コンポーネントや画面が破棄された後に結果が返ってきた場合

これらを明示的に扱っておくと、状態が偶然矛盾することを防ぎやすくなります。
特に非同期処理では、コードを書いた時点では想定していなかったタイミングでイベントが発生するため、「正しい順序で呼ばれる」という前提をできるだけ減らすことが重要です。

最終的に目指したいのは、現在の状態と入力から次の状態を説明できる設計です。
処理のどこで停止しているのかを暗黙的に把握するのではなく、状態そのものを観測できるようにする。
非同期処理はasync/awaitで制御し、副作用を分離し、状態遷移を独立してテストする。
この構造なら、yieldを使う場合でも使わない場合でも、設計の意図を明確に保てます。

そしてテストを書くときには、特定の構文や内部実装へ依存しすぎないことが重要です。
状態遷移、エラー処理、競合状態、境界条件という観点から振る舞いを検証すれば、将来的に実装方式を変更する場合でも安全にリファクタリングできます。
状態管理における「安全」とは、単にバグが少ないことではなく、状態の意味と変化を人間が追跡でき、機械的にも検証できることです。

ここまでの設計を踏まえると、yieldを避けるべきケースもかなり具体的に判断できるようになります。
最後に、ジェネレータが適している場面と避けたほうがよい場面、そして代替パターンを整理し、JavaScriptにおける安全な状態管理の考え方をまとめます。

JavaScriptのyieldを避けるべきケースと安全な状態管理のまとめ

JavaScriptのyieldを使わず状態を安全に管理する方法のまとめ

ここまで、JavaScriptのyieldがどのような仕組みで動作し、どのような場面で便利なのか、そして状態管理を目的として利用する場合にどのような問題が起こりやすいのかを見てきました。
結論から言えば、yieldそのものを避けるべきという話ではありません。
重要なのは、処理の目的に対して適切な抽象化を選択することです。

yieldはジェネレータ関数の実行を一時停止し、呼び出し側から再開できる強力な機能です。
値を必要なタイミングで生成したい場合や、大量のデータを遅延評価したい場合、無限に続くシーケンスを扱いたい場合など、ジェネレータの性質がそのまま問題の構造に対応するケースでは非常に有効です。

一方で、「現在の状態を保持したい」「状態遷移を明示したい」「APIの完了を待ちたい」といった目的では、yieldを中心に設計する必要性は低くなります。
ジェネレータの実行位置を状態の代わりに利用すると、状態の意味がコード上で直接表現されず、呼び出し回数や実行順序に依存した設計になりやすいためです。

yieldを避けたほうがよい代表的なケース

特に注意したいのは、yieldによる停止・再開を「状態を保存するための仕組み」として利用しているケースです。
例えば、ジェネレータがどのyieldまで進んでいるかによって「初期状態」「処理中」「完了」といった意味を表現している場合、状態そのものが明示的なデータになっていません。

この設計では、現在の状態を確認するためにジェネレータの内部実行位置を推測する必要があります。
さらに、途中に条件分岐やループが増えると、何回next()を呼べばどこまで進むのかという関係も複雑になります。
仕様変更によってyieldの位置が変われば、呼び出し側やテストにも影響が及ぶ可能性があります。

また、API通信などの非同期処理を制御するためだけにジェネレータを使うケースも、現在では慎重に検討すべきです。
以前はジェネレータとPromiseを組み合わせて非同期処理を順番に実行するパターンが利用されることもありました。
しかし現在のJavaScriptでは、async/awaitによって非同期処理の待機を直接表現できます。

したがって、次のような判断が一つの目安になります。

  • 値を段階的に生成することが目的なら、yieldを積極的に検討する
  • 内部状態を保持して操作することが目的なら、クロージャを検討する
  • 状態そのものを明示し、遷移を管理したいなら、状態オブジェクトや状態遷移関数を検討する
  • Promiseの完了を待って処理を進めたいなら、async/awaitを検討する

これは「この機能は禁止」というルールではありません。
問題の性質に合わせて、最も直接的に意図を表現できる方法を選ぶための基準です。

安全な状態管理では状態を観測可能にする

安全な状態管理を設計するうえで、特に重要なのが状態の観測可能性です。
現在どの状態なのか、その状態からどのイベントを受け付けられるのか、イベントを受けた結果として何へ遷移するのか。
この情報がコードから追跡できることが重要です。

yieldを状態表現として利用すると、状態がジェネレータの内部実行位置へ隠れてしまうことがあります。
それに対して、状態をオブジェクトや列挙値として保持すれば、デバッガーやログから現在値を直接確認できます。
テストでも「この入力に対してこの状態になる」という仕様として検証しやすくなります。

さらに、状態遷移を独立した関数として設計できれば、外部サービスやDOMなどの副作用から切り離してテストできます。
例えば「STARTというイベントを受けたらloadingへ移行する」「SUCCESSならsuccessへ移行する」といったルールを、通信処理とは独立して検証できます。

これは単なるコードの整理ではありません。
状態遷移を数学的な関数に近づけることで、入力と出力の関係が明確になります。
状態数が増えた場合でも、どの遷移が定義され、どの遷移が未定義なのかを確認しやすくなります。

非同期処理と状態管理を混ぜない

async/awaitについても同じ考え方が当てはまります。
awaitは非同期処理の完了を待つための構文であり、アプリケーションの状態そのものを管理する仕組みではありません。

例えばAPIを呼び出している間に画面をloading状態にする場合、awaitが状態を管理してくれるわけではありません。
リクエストを開始したときに状態を変更し、成功したら成功状態へ、失敗したらエラー状態へ変更するという設計が必要です。

この責務を分離すると、「非同期処理の制御」と「状態遷移」という二つの問題を個別に考えられます。
結果としてコードのテストもしやすくなります。
非同期処理については通信の成功・失敗を確認し、状態遷移については各イベントに対する状態変化を確認するという具合です。

ただし、非同期処理には競合状態という別の問題があります。
複数のリクエストが並行して実行される場合、開始順と完了順が一致するとは限りません。
古いリクエストの結果で新しい状態が上書きされないか、キャンセルされた処理の結果を無視できるか、といった点まで設計する必要があります。

つまり、yieldをasync/awaitへ置き換えればすべて安全になるわけではありません。
状態の意味、遷移ルール、非同期処理の競合をそれぞれ設計することが必要です。

テストでは実装詳細ではなく振る舞いを確認する

状態管理を長期的に保守するなら、テストの設計も重要です。
ジェネレータを使っている場合に「next()を何回呼ぶか」をテストの中心にすると、実装変更に弱いテストになりやすくなります。
yieldの位置を変更しただけでテストが壊れるなら、そのテストはビジネス上の振る舞いではなく実装詳細へ依存している可能性があります。

より望ましいのは、外部から観測できる状態や結果を検証することです。
開始操作を行った結果が正しい状態になるか、成功したデータが保持されるか、エラー時に適切な状態へ遷移するか、といった観点です。
これなら内部実装がジェネレータであっても、状態オブジェクトであっても、テストの目的は変わりません。

さらに、正常系だけでなく境界条件も確認します。
同じイベントが連続して発生した場合、想定外のイベントが届いた場合、非同期処理が逆順で完了した場合、途中でキャンセルされた場合などです。
状態管理のバグは、このような「普通なら起こらないと思っていた順序」で発生することが多いためです。

最終的な判断基準

最終的には、yieldを使うかどうかを構文の好みで決めるのではなく、データと制御フローの関係から判断します。
ジェネレータの「次の値を要求されるまで処理を進めない」という性質が必要なら、yieldは適切な選択です。
反対に、ジェネレータの停止位置を状態の代わりに使っているだけなら、別の設計を検討する価値があります。

状態を管理するなら、状態をデータとして明示する。
状態を変更する操作を限定する。
状態遷移を独立して検証できるようにする。
非同期処理を待つならasync/awaitを利用する。
そして、テストでは内部の実装手順ではなく、外部から観測できる振る舞いを確認する。
この原則を押さえておけば、コードが大きくなっても設計意図を維持しやすくなります。

JavaScriptには非常に多くの制御構文や抽象化手段があります。
しかし、表現力が高い機能ほど、目的に合わない使い方をするとコードの理解に必要なコストも増えます。
yieldも例外ではありません。
便利だから使うのではなく、「この問題を表現するためにジェネレータというモデルが本当に自然なのか」と問い直すことが重要です。

状態管理において目指すべきなのは、単に短いコードを書くことではありません。
現在の状態が何を意味し、どの操作によって、どの条件で次の状態へ変化するのかを誰が読んでも追跡できることです。
そのためにクロージャ、状態オブジェクト、async/awaitなどを適切に使い分けます。

yieldを避けるべきケースとは、yieldが悪いケースではなく、ジェネレータの実行位置を状態管理や非同期制御の代用品として使うことで、かえって設計が不透明になるケースです。
目的に適した抽象化を選び、状態を明示し、遷移をテスト可能にする。
この基本に立ち返れば、JavaScriptの状態管理はより予測可能で、保守しやすいものになります。

コメント

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