你真的会用Generator吗？这7个经典案例让你彻底开窍-优快云博客

第一章：Generator函数的核心原理与优势

Generator函数是JavaScript中一种特殊的函数类型，允许在执行过程中暂停和恢复，为异步编程提供了更优雅的解决方案。其核心在于通过 `function*` 语法定义，并结合 `yield` 和 `return` 实现分段执行。

执行机制与状态控制

Generator函数返回一个可迭代的迭代器对象，调用其 `next()` 方法才会执行到下一个 `yield` 表达式。每次调用 `next()` 返回一个包含 `value` 和 `done` 的对象，分别表示当前产出值和是否执行完毕。

function* counter() {
  yield 1;
  yield 2;
  return 3; // 最终返回值
}

const gen = counter();
console.log(gen.next()); // { value: 1, done: false }
console.log(gen.next()); // { value: 2, done: false }
console.log(gen.next()); // { value: 3, done: true }

上述代码展示了Generator函数如何逐步输出值并控制执行流程。

核心优势对比传统函数

惰性求值：仅在需要时计算下一个值，适用于无限序列处理
状态保持：函数内部状态在暂停期间得以保留
双向通信：通过 next(value) 可向生成器内部传入数据

特性	普通函数	Generator函数
执行方式	一次性运行完成	可中断、分步执行
返回值	单一返回结果	多次yield输出
状态管理	无法暂停	自动保存执行上下文

graph TD A[调用 generator()] --> B{返回迭代器} B --> C[调用 next()] C --> D[执行到 yield] D --> E[暂停并返回 value] E --> F[再次调用 next()] F --> G[恢复执行]

第二章：基础应用中的Generator实战

2.1 理解迭代器协议与next方法的精巧设计

在Python中，迭代器协议是构建可迭代对象的核心机制，其本质依赖于两个特殊方法：`__iter__()` 和 `__next__()`。通过实现这两个方法，对象能够按需返回下一个值，而非一次性加载全部数据。

迭代器的基本结构

class CountIterator:
    def __init__(self, low, high):
        self.current = low
        self.high = high

    def __iter__(self):
        return self

    def __next__(self):
        if self.current > self.high:
            raise StopIteration
        else:
            self.current += 1
            return self.current - 1

该代码定义了一个计数迭代器。`__next__` 方法每次被调用时返回当前值并递增，直到超出上限时抛出 `StopIteration` 异常，通知循环终止。

协议设计的优势

内存高效：惰性计算避免存储完整序列
统一接口：所有可迭代类型遵循相同行为规范
控制精确：开发者可自定义迭代逻辑和终止条件

2.2 实现可暂停的计数器：掌握yield的基本用法

在生成器函数中，yield 关键字用于暂停执行并返回一个值，之后可从中断处恢复。通过这一机制，可实现一个可暂停的计数器。

基本实现

def counter():
    count = 0
    while True:
        yield count
        count += 1

该生成器每次调用 next() 时返回当前计数值，并暂停执行，直到下一次调用。变量 count 在多次调用间保持状态。

控制执行流程

yield 返回值后暂停，保留局部变量上下文；
再次调用时从暂停位置继续；
适用于惰性计算、内存敏感场景。

2.3 使用return和throw控制生成器状态流转

在生成器函数中，`return` 和 `throw` 提供了精确控制状态流转的机制。它们不仅能终止迭代过程，还可携带数据或异常信息，影响后续执行逻辑。

使用 return 终止并返回值

当在生成器中调用 `return` 时，会立即结束迭代，并将值赋给 `value` 属性，同时设置 `done: true`。


function* gen() {
  yield 1;
  return "end";
}
const g = gen();
console.log(g.next()); // { value: 1, done: false }
console.log(g.next()); // { value: "end", done: true }

该代码表明，`return` 提前终结生成器，后续调用 `next()` 不再产生新值。

使用 throw 抛出异常中断流程

通过 `g.throw(err)` 可在暂停点注入异常，触发生成器内部的错误处理逻辑。

若生成器内有 try-catch，则可捕获该异常；
否则，异常将向上冒泡，终止生成器运行。

2.4 构建无限序列：展示惰性求值的强大能力

惰性求值允许我们定义理论上无限长的数据结构，而只在需要时计算实际使用的部分。这种机制在处理大规模或无限数据流时展现出极高的效率和表达力。

生成无限自然数序列

func Natural() chan int {
    ch := make(chan int)
    go func() {
        for i := 1; ; i++ {
            ch <- i
        }
    }()
    return ch
}

该函数返回一个通道，持续发送递增的自然数。由于使用 goroutine 异步填充，调用者可按需从通道读取前 N 个值，无需预先计算整个序列。

惰性过滤与组合

通过链式处理，可构建如“无限质数序列”等复杂结构。每次迭代仅计算下一个元素，内存占用恒定，充分体现了惰性求值在资源控制和抽象能力上的优势。

2.5 双向通信：通过next传参实现动态交互

在响应式编程中，`next` 方法不仅是数据流的推送通道，更是实现双向通信的核心机制。通过向 `next` 传递参数，观察者与被观察者之间可建立动态交互模型。

数据推送与状态反馈

调用 `next(value)` 不仅发送数据，还可携带控制指令或状态信息，实现下游对上游的行为影响。


subject.next({ 
  type: 'UPDATE', 
  payload: 'new data',
  callback: () => console.log('processed') 
});

上述代码中，`next` 传递的对象包含操作类型、数据负载及回调函数，允许接收方处理后反向通知，形成闭环通信。

典型应用场景

表单输入实时校验与反馈
分页请求与响应的联动控制
UI组件间的状态同步

这种模式提升了系统的响应性与协作能力，使数据流更具语义和交互深度。

第三章：异步编程中的Generator进阶技巧

3.1 Generator + Promise 封装异步任务链

在处理复杂异步流程时，Generator 函数与 Promise 的结合提供了一种优雅的同步书写风格。通过 yield 暂停执行，将 Promise 实例交由运行器处理，实现异步任务的串行化管理。

基础封装模式

function run(generator) {
  const iterator = generator();
  function handle(result) {
    if (result.done) return result.value;
    return result.value.then(res => 
      handle(iterator.next(res))
    );
  }
  return handle(iterator.next());
}

上述 run 函数接收一个生成器，递归调用 next 并自动解析 Promise 结果，形成自动执行机制。

实际应用示例

yield 后可接任意 Promise 异步操作，如 fetch 请求
错误可通过 try/catch 在生成器内部捕获
逻辑清晰，避免回调嵌套

3.2 手动实现co函数库的核心调度逻辑

在异步编程中，`co` 函数库通过自动执行生成器函数并解析 `Promise` 结果，极大简化了异步流程控制。其核心在于递归调度与状态管理。

执行器的基本结构

手动实现的关键是编写一个能捕获生成器每次产出值并处理为 Promise 的执行函数：

function co(genFn) {
  return function() {
    const gen = genFn.apply(this, arguments);
    return new Promise((resolve, reject) => {
      function next(value) {
        let ret;
        try {
          ret = gen.next(value);
        } catch (e) {
          return reject(e);
        }
        if (ret.done) return resolve(ret.value);
        Promise.resolve(ret.value).then(next, reject);
      }
      next();
    });
  };
}

上述代码中，next() 函数递归调用自身，将上一步的 Promise 结果传入 gen.next()，形成自动推进机制。当 done: true 时终止并返回最终值。

调度流程解析

启动生成器，获取首个迭代结果
将产出值包裹为 Promise，确保异步统一性
通过 then 捕获成功回调，继续推进生成器
异常由 reject 统一处理，保证错误冒泡

3.3 错误冒泡机制：在生成器中统一处理异步异常

在异步生成器中，错误冒泡机制确保未捕获的异常能沿调用栈向上传递，最终被外层 try/catch 捕获。这一机制简化了异步流程中的错误管理。

异常传播路径

异步生成器函数执行时，每次 yield 都可能抛出异常。若未在当前作用域处理，异常会自动向上冒泡至调用者。


async function* asyncGenerator() {
  yield Promise.resolve(1);
  throw new Error("异步任务失败");
}

(async () => {
  try {
    for await (const val of asyncGenerator()) {
      console.log(val);
    }
  } catch (err) {
    console.error("捕获异常:", err.message); // 输出: 捕获异常: 异步任务失败
  }
})();

上述代码中，生成器内部抛出的错误被外部 try/catch 捕获，体现了错误冒泡的有效性。Promise 链中的拒绝（rejection）也会以相同方式传播。

统一错误处理优势

减少重复的错误捕获逻辑
提升代码可读性和维护性
支持集中式日志记录与监控

第四章：复杂场景下的Generator工程实践

4.1 实现任务队列调度器：控制并发执行流程

在高并发系统中，任务队列调度器是协调资源与执行效率的核心组件。通过限制同时运行的协程数量，可避免资源耗尽并提升稳定性。

基本结构设计

使用带缓冲的通道控制并发数，任务通过函数类型封装，便于统一调度。


type Task func() error

func NewScheduler(maxWorkers int) *Scheduler {
    return &Scheduler{
        taskCh: make(chan Task, 100),
        maxWorkers: maxWorkers,
    }
}

taskCh 存放待执行任务，maxWorkers 控制最大并发工作协程数。

并发执行逻辑

启动固定数量的工作协程从通道消费任务：

每个 worker 持续监听任务通道
接收到任务后同步执行
错误可通过返回值统一捕获处理

4.2 状态机管理：用Generator替代复杂的switch逻辑

在实现复杂状态流转时，传统的 switch-case 逻辑往往导致代码臃肿且难以维护。Generator 函数提供了一种更优雅的解决方案，通过暂停执行的能力，将状态转移清晰地表达为线性流程。

状态机的基本结构

使用 Generator 可以将状态机建模为可迭代的过程，每个 yield 表达式代表一个状态输出：

function* stateMachine() {
  yield 'IDLE';
  yield 'LOADING';
  yield 'SUCCESS';
  return 'END';
}

该函数每次调用 next() 返回当前状态并暂停，避免了嵌套判断。

动态状态转移控制

结合外部输入驱动状态跳转，可实现条件转移：

通过 next(data) 传入事件触发转移
利用闭包维护当前状态上下文
消除大量 if/switch 分支判断

这种方式显著提升了状态逻辑的可读性与可测试性。

4.3 数据流管道构建：组合多个生成器处理大数据流

在处理大规模数据流时，单一生成器往往难以满足性能与扩展性需求。通过组合多个生成器，可构建高效、可维护的数据流管道。

生成器链式调用

利用生成器的惰性求值特性，将多个处理阶段串联成管道，避免中间结果驻留内存。


def read_lines(filename):
    with open(filename) as f:
        for line in f:
            yield line.strip()

def filter_empty(lines):
    for line in lines:
        if line:
            yield line

def to_uppercase(lines):
    for line in lines:
        yield line.upper()

# 构建数据流管道
pipeline = to_uppercase(filter_empty(read_lines('data.txt')))
for processed in pipeline:
    print(processed)

上述代码中，read_lines 逐行读取文件，filter_empty 过滤空行，to_uppercase 转换为大写。三者通过参数传递形成流水线，每步仅处理当前所需数据，显著降低内存占用。

优势分析

内存友好：数据逐项流动，无需加载全量数据
职责分离：每个生成器专注单一转换逻辑
易于扩展：可灵活插入新处理阶段

4.4 深度遍历树结构：利用递归生成器简化算法实现

在处理树形数据结构时，深度优先遍历是常见需求。传统递归方法常需维护额外的状态变量，而使用递归生成器可显著简化代码逻辑。

生成器的优势

Python 的生成器函数通过 yield 逐个返回节点，延迟计算并节省内存。尤其适合大型树结构的遍历。


def dfs_traverse(node):
    if not node:
        return
    yield node.value
    for child in node.children:
        yield from dfs_traverse(child)

上述代码中，yield from 将子调用的生成器“展平”到当前上下文中。调用者可通过迭代直接获取所有节点值，无需关心递归细节。

性能对比

方式	空间复杂度	可读性
递归+列表收集	O(n)	中等
递归生成器	O(h)	高

其中 h 为树的高度，生成器避免了中间结果的存储开销。

第五章：从Generator到现代JS异步方案的演进思考

异步编程的演变路径

JavaScript异步编程经历了从回调地狱到Promise，再到Generator函数，最终演化为async/await的清晰流程。每一步演进都旨在提升代码可读性与错误处理能力。

Generator函数的实际局限

虽然Generator函数通过yield实现了暂停执行，可用于异步流程控制，但其手动调用next()的机制在复杂场景中难以维护。例如：


function* asyncFlow() {
  const data = yield fetch('/api/data');
  yield console.log(data);
}
const gen = asyncFlow();
gen.next().value.then(res => gen.next(res));

这种模式需要额外的运行器来驱动，增加了实现复杂度。

async/await的工程优势

现代项目普遍采用async/await，因其语法更贴近同步书写习惯，且天然支持try/catch错误捕获。以下为真实案例中的优化对比：

方案	错误处理	调试友好性	堆栈追踪
回调函数	分散难维护	差	断裂
Promise链	集中但需.catch()	中等	部分保留
async/await	支持try/catch	优秀	完整保留

迁移实践建议

遗留系统中可使用co库兼容Generator逻辑
新项目应直接采用async/await + Promise.allSettled进行并发控制
注意避免在循环中滥用await导致串行化性能问题

[事件循环] → [微任务队列(Promise)] → [宏任务(如setTimeout)]  
async函数返回Promise，其内部await会将后续操作推入微任务