生成器（Generators）：创建自定义迭代器 (ES6+)

引言

大家好，欢迎来到今天的讲座！今天我们要聊的是 JavaScript 中的一个非常酷炫的特性——生成器（Generators）。如果你曾经写过复杂的循环、递归函数，或者处理过异步代码，那么生成器可能会成为你新的“救命稻草”。它不仅可以让你更轻松地创建自定义迭代器，还能帮你写出更简洁、更易读的代码。

在 ES6 之前，如果你想实现一个自定义的迭代器，通常需要手动管理状态和返回值。这不仅繁琐，还容易出错。而生成器的出现，让这一切变得简单得多。接下来，我们就一起来看看生成器是如何工作的，以及它能为我们带来哪些便利。

什么是生成器？

生成器是一种特殊的函数，它可以在执行过程中暂停，并在稍后恢复执行。你可以把它想象成一个可以“暂停”的函数。与普通函数不同，生成器不会一次性执行完所有代码，而是可以在每次调用时逐步返回结果，直到完成整个函数的执行。

生成器函数的定义方式很简单，只需要在 function 关键字后面加上一个星号 *，就像这样：

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

这里的 yield 关键字是生成器的核心。它告诉 JavaScript：“嘿，我这里有一个值可以返回，但我不想继续往下执行，先暂停一下吧。” 当你调用这个生成器函数时，它并不会立即执行所有代码，而是返回一个 迭代器对象，你可以通过这个对象来控制生成器的执行。

迭代器对象

当你调用生成器函数时，它会返回一个迭代器对象。这个对象有两个重要的方法：

next()：用于继续执行生成器，并返回下一个 yield 的值。
return()：用于提前结束生成器，并返回一个最终值。
throw()：用于向生成器抛出异常，模拟错误处理。

我们来看一个简单的例子：

const gen = myGenerator();

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

每次调用 next()，生成器都会从上次暂停的地方继续执行，直到遇到下一个 yield 或者函数结束。当生成器执行完毕后，done 属性会被设置为 true，表示生成器已经完成了所有的值生成。

生成器的好处

1. 简化复杂逻辑

生成器的一个重要优势是它可以简化复杂的逻辑，尤其是那些需要逐步处理数据的情况。比如，假设你要实现一个斐波那契数列生成器，使用传统的函数可能需要维护大量的状态变量，而使用生成器则可以轻松实现：

function* fibonacci() {
  let [prev, curr] = [0, 1];
  while (true) {
    yield curr;
    [prev, curr] = [curr, prev + curr];
  }
}

const fib = fibonacci();
console.log(fib.next().value); // 1
console.log(fib.next().value); // 1
console.log(fib.next().value); // 2
console.log(fib.next().value); // 3
console.log(fib.next().value); // 5

在这个例子中，生成器帮助我们避免了手动管理状态变量的麻烦，代码更加简洁易读。

2. 惰性求值

生成器的另一个好处是它支持 惰性求值（Lazy Evaluation）。这意味着生成器不会一次性计算所有值，而是在你需要的时候才生成下一个值。这对于处理大量数据或无限序列非常有用，因为你可以按需获取值，而不需要一次性加载所有数据到内存中。

举个例子，假设你要生成一个无限的自然数序列，使用生成器可以轻松实现：

function* naturalNumbers() {
  let num = 0;
  while (true) {
    yield num++;
  }
}

const numbers = naturalNumbers();
console.log(numbers.next().value); // 0
console.log(numbers.next().value); // 1
console.log(numbers.next().value); // 2
// 你可以一直调用 next() 来获取更多的自然数

3. 异步编程中的应用

生成器还可以与异步编程结合使用，尤其是在 ES6 之前的年代，生成器是处理异步操作的一种常见方式。虽然现在我们有了 async/await，但在某些场景下，生成器仍然可以派上用场。

例如，你可以使用生成器来实现一个简单的异步任务调度器：

function* asyncTaskScheduler() {
  console.log('Step 1');
  yield new Promise(resolve => setTimeout(() => resolve('Task 1'), 1000));
  console.log('Step 2');
  yield new Promise(resolve => setTimeout(() => resolve('Task 2'), 1000));
  console.log('Step 3');
}

function run(generator) {
  const iter = generator();
  function handlePromise(promise) {
    promise.then(result => {
      console.log(result);
      const next = iter.next();
      if (!next.done) {
        handlePromise(next.value);
      }
    });
  }
  handlePromise(iter.next().value);
}

run(asyncTaskScheduler);

在这个例子中，生成器帮助我们将异步任务分解成多个步骤，并且可以通过 yield 来暂停执行，等待每个异步操作完成后再继续下一步。

生成器与 `for...of` 循环

生成器返回的迭代器对象可以与 for...of 循环完美配合，这使得我们可以更方便地遍历生成器返回的值。比如，我们可以用 for...of 来遍历前面提到的斐波那契数列生成器：

function* fibonacci() {
  let [prev, curr] = [0, 1];
  while (true) {
    yield curr;
    [prev, curr] = [curr, prev + curr];
  }
}

const fib = fibonacci();
for (let i = 0; i < 10; i++) {
  console.log(fib.next().value);
}

你也可以直接将生成器传递给 for...of，它会自动调用生成器的 next() 方法来获取值：

for (const num of fibonacci()) {
  console.log(num);
  if (num > 100) break; // 限制输出范围
}

生成器的状态管理

生成器的一个有趣特性是它可以在暂停时接收外部输入。通过 next() 方法传递参数，你可以在生成器内部接收这些参数并根据它们调整逻辑。比如，我们可以实现一个简单的计数器生成器，并允许外部传入增量值：

function* counter(initialValue = 0) {
  let count = initialValue;
  while (true) {
    const increment = yield count;
    if (increment !== undefined) {
      count += increment;
    } else {
      count++;
    }
  }
}

const c = counter(5);
console.log(c.next().value); // 5
console.log(c.next().value); // 6
console.log(c.next(3).value); // 9
console.log(c.next().value); // 10

在这个例子中，next(3) 传递了一个增量值 3，生成器接收到这个值后将其加到当前计数器上。这种机制使得生成器可以与外部环境进行交互，增加了它的灵活性。

生成器的局限性

虽然生成器非常强大，但它也有一些局限性。首先，生成器一旦启动，就无法回退到之前的状态。也就是说，生成器只能向前推进，不能倒退或重新开始。其次，生成器的语法相对较为特殊，初学者可能会觉得有些难以理解。

此外，生成器在处理异步操作时，虽然可以简化代码，但在现代 JavaScript 中，async/await 已经成为了更常用的选择。因此，在大多数情况下，生成器更多地被用于创建自定义迭代器或处理惰性求值的场景。

总结

好了，今天的讲座到这里就差不多结束了！我们回顾一下生成器的主要特点：

生成器是一种可以暂停和恢复执行的特殊函数。
它通过 yield 关键字返回值，并可以在每次调用 next() 时继续执行。
生成器可以简化复杂逻辑、支持惰性求值，并且可以与异步编程结合使用。
生成器返回的迭代器对象可以与 for...of 循环配合使用，方便遍历生成的值。
生成器可以在暂停时接收外部输入，增加了它的灵活性。

希望今天的讲解对你有所帮助！如果你有任何问题，欢迎随时提问。下次再见！