利用生成器函数简化JS迭代器的创建过程

一、传统手写迭代器的机制与繁琐痛点

要理解生成器函数的价值，首先需要明确 JavaScript 的“双迭代协议”：可迭代协议（Iterable Protocol）与迭代器协议（Iterator Protocol）。一个对象要成为可迭代对象，其内部或原型链上必须拥有一个属性名为 [Symbol.iterator] 的无参方法；该方法必须返回一个符合迭代器协议的对象，即包含一个返回 { value: any, done: boolean } 的 next() 方法。

为了直观感受传统手写迭代器的复杂度，我们以实现一个能够按指定步长生成数值序列的 NumberRange 类为例：

// 传统方式：手动实现迭代器协议与可迭代协议
class NumberRange {
  constructor(start, end, step = 1) {
    this.start = start;
    this.end = end;
    this.step = step;
  }

  // 遵循可迭代协议
  [Symbol.iterator]() {
    // 1. 手动在闭包中维护游标状态
    let current = this.start;
    const end = this.end;
    const step = this.step;

    // 2. 返回符合迭代器协议的对象
    return {
      next() {
        if (current <= end) {
          const value = current;
          current += step; // 手工推进状态
          return { value: value, done: false };
        } else {
          return { value: undefined, done: true };
        }
      },
      // 保证迭代器自身也是可迭代的（便于复用）
      [Symbol.iterator]() {
        return this;
      }
    };
  }
}

// 验证消费
const range = new NumberRange(1, 5, 2);
for (const num of range) {
  console.log(num); // 依次输出: 1, 3, 5
}

观察上述代码可以发现，虽然核心需求仅仅是“从 start 累加到 end”，但开发者必须承受以下四个维度的工程负担：

• 外部游标状态外置：必须通过额外的闭包变量 current 暂存执行进度。若逻辑分支增多，多变量协同维护极易引入状态同步错误。
• 模板对象硬编码：每次调用 next() 都必须手动构造形如 { value, done } 的字面量，不仅冗余而且增加垃圾回收负担。
• 双重协议补丁：若要让返回的迭代器自身能在其他流式工具中复用，还必须额外在返回对象上添加 [Symbol.iterator]() { return this; } 样板。
• 嵌套结构无力：当需要遍历二叉树、图或嵌套链表时，手动用循环和栈模拟递归迭代的代码复杂度将呈指数级增长。

二、生成器函数简化迭代的核心机制

生成器函数（带有星号声明的 function*）之所以能够彻底瓦解上述痛点，是因为 ECMAScript 引擎在语言底层为其注入了三大自动化能力：

1. 执行上下文的按需挂起与无缝恢复

普通函数在调用后会一直执行到 return 或末尾退出，执行栈随即销毁；而生成器函数被调用时，不会立即执行其内部代码，而是返回一个特殊的 Generator 对象。

只有当外部调用该对象的 next() 方法时，函数体才开始或恢复执行。一旦在函数体内遇到 yield 表达式，引擎便会立即计算其后的表达式，将其作为返回值向外传递，同时暂停执行并完整冻结当前函数的执行上下文（包括作用域内的所有局部变量、循环条件及指令计数器指针）。当下次再次调用 next() 时，程序会从上次暂停的位置无缝继续，局部变量值完全保持不变。

2. 规范结果对象的自动包装

在生成器函数内部，开发者不再需要显式构造对象。编写 yield x 时，引擎在底层会自动将其封装为标准的 { value: x, done: false }；当函数自然执行至末尾或执行 return y 时，引擎会自动产出 { value: y, done: true }。

3. 迭代器与可迭代协议的原生合一

生成器函数返回的 Generator 原型链深度整合了 ECMAScript 规范。它既拥有符合迭代器协议的 next()、return()、throw() 方法，其原型上又预先定义了 [Symbol.iterator]() { return this; }。这意味着由生成器产出的对象可以直接交给 for...of、展开语法或第三方流式库消费，无需任何适配胶水代码。

三、实战重构：从手写样板到生成器极简实现

理解了生成器的机制后，我们可以将任意自定义对象的迭代器改造归纳为标准的三步操作。

第一步：声明生成器方法替代工厂闭包

在类定义或对象字面量中，直接将 [Symbol.iterator] 声明为生成器方法，语法为在名称前添加星号：*[Symbol.iterator]()。这省去了原先包裹在方法外层的工厂函数和闭包环境。

第二步：用自然控制流与 yield 替代游标维护

抛弃原先的 current 游标暂存与边界条件判断，直接使用最自然的 while 或 for 循环，在需要产出数据处直接书写 yield。

以下是将前文 NumberRange 类重构后的完整代码：

// 生成器重构版：仅需保留纯粹的数值累加逻辑
class NumberRange {
  constructor(start, end, step = 1) {
    this.start = start;
    this.end = end;
    this.step = step;
  }

  // 一步到位：直接声明生成器方法
  *[Symbol.iterator]() {
    for (let i = this.start; i <= this.end; i += this.step) {
      yield i; // 产出当前值，自动冻结循环上下文
    }
  }
}

// 消费验证完全相同
const range = new NumberRange(1, 5, 2);
console.log([...range]); // 输出: [1, 3, 5]

原本需要 25 行的手工状态机代码，在重构后仅用了 5 行核心循环，代码行数精简了 80%，逻辑的直观性和可读性得到了质的飞跃。

第三步：利用 yield* 无痛遍历嵌套层级与树形结构

面对树形节点、多维目录或链表等递归数据结构时，生成器的 yield*（委托语法）能发挥更大的威能。yield* 可以将迭代权无缝委托给另一个可迭代对象或生成器，彻底消除了显式维护递归调用栈或预先将整棵树压平到临时数组的巨大内存开销。

// 实战案例：二叉搜索树（BST）的中序遍历生成器
class TreeNode {
  constructor(value, left = null, right = null) {
    this.value = value;
    this.left = left;
    this.right = right;
  }

  // 中序遍历：左子树 -> 根节点 -> 右子树
  *[Symbol.iterator]() {
    if (this.left) {
      yield* this.left;  // 委托给左子树的迭代器
    }
    yield this.value;    // 产出自身值
    if (this.right) {
      yield* this.right; // 委托给右子树的迭代器
    }
  }
}

// 构建一棵简单的树：   4
//                    / \
//                   2   6
const tree = new TreeNode(4, new TreeNode(2), new TreeNode(6));

// 直接使用 for...of 遍历树，按自然排序输出
for (const val of tree) {
  console.log(val); // 顺序输出: 2, 4, 6
}

在传统写法中，要使一棵树支持 for...of，通常需要用数组配合显式辅助栈做非递归迭代。而通过 yield*，递归迭代的调用链被直接嵌入到生成器迭代管线中，不仅按需惰性产出每个节点，而且空间复杂度仅与树的最大深度成正比。

四、高级应用场景与工程注意事项

生成器函数不仅适用于常规集合的轻量包装，在高性能场景与边界处理中同样展现出卓越的工程特性。

1. 惰性计算与无限序列流水线

因为 yield 是被动求值的（仅在调用方需要下一个元素时才计算），生成器是构建海量数据切片和无限序列的理想载体。

// 无限 ID 序列发生器：不占用持续堆内存，按需取值
function* idGenerator(prefix = "item") {
  let count = 1;
  while (true) {
    yield `${prefix}_${count++}`;
  }
}

const gen = idGenerator("order");
console.log(gen.next().value); // order_1
console.log(gen.next().value); // order_2

2. 异常退出与资源清理保障

在迭代器消费过程中，循环可能由于 break、return 或未捕获异常而提前终止。生成器函数内部支持完整的 try...finally 结构。当外部中断迭代时，运行时会自动调用迭代器的 return() 方法，强制跳转执行 finally 块，确保文件句柄、网络通道或数据库游标被妥善关闭。

function* resourceIterator() {
  console.log("资源已打开");
  try {
    yield "A";
    yield "B";
  } finally {
    console.log("迭代中断或完成，执行资源清理");
  }
}

for (const item of resourceIterator()) {
  if (item === "A") break; // 触发中断
}
// 控制台输出:
// 资源已打开
// 迭代中断或完成，执行资源清理