第 7 章 迭代器与生成器

7.1 理解迭代

在 JavaScript 中，计数循环就是一种最简单的迭代。

循环是迭代机制的基础，这是因为它可以指定迭代的次数，以及每次迭代要执行什么操作。每次循环都会在下一次迭代开始之前完成，而每次迭代的顺序都是事先定义好的。

迭代会在一个有序集合上进行。​（​“有序”可以理解为集合中所有项都可以按照既定的顺序被遍历到，特别是开始和结束项有明确的定义。​）数组是 JavaScript 中有序集合的最典型例子。

❑ 迭代之前需要事先知道如何使用数据结构。数组中的每一项都只能先通过引用取得数组对象，然后再通过[​]操作符取得特定索引位置上的项。这种情况并不适用于所有数据结构。
❑ 遍历顺序并不是数据结构固有的。通过递增索引来访问数据是特定于数组类型的方式，并不适用于其他具有隐式顺序的数据结构。

ES5 新增了 Array.prototype.forEach()方法，向通用迭代需求迈进了一步（但仍然不够理想）​。

这个方法解决了单独记录索引和通过数组对象取得值的问题。不过，没有办法标识迭代何时终止。因此这个方法只适用于数组，而且回调结构也比较笨拙。

7.2 迭代器模式

7.2.1 可迭代协议

实现 Iterable 接口（可迭代协议）要求同时具备两种能力：支持迭代的自我识别能力和创建实现 Iterator 接口的对象的能力。在 ECMAScript 中，这意味着必须暴露一个属性作为“默认迭代器”​，而且这个属性必须使用特殊的 Symbol.iterator 作为键。这个默认迭代器属性必须引用一个迭代器工厂函数，调用这个工厂函数必须返回一个新迭代器。

很多内置类型都实现了 Iterable 接口：

❑ 字符串
❑ 数组
❑ 集合
❑ arguments 对象
❑ NodeList 等 DOM 集合类型

检查是否存在默认迭代器属性可以暴露这个工厂函数：

let num = 1
let obj = {}
// 这两种类型没有实现迭代器工厂函数
console.log(num[Symbol.iterator]) // undefined
console.log(obj[Symbol.iterator]) // undefined
let str = 'abc'
// 这些类型都实现了迭代器工厂函数
console.log(str[Symbol.iterator]) // f values() { [native code] }
// 调用这个工厂函数会生成一个迭代器
console.log(str[Symbol.iterator]()) // StringIterator {}

接收可迭代对象的原生语言特性包括：

❑ for-of 循环
❑ 数组解构
❑ 扩展操作符
❑ Array.from()
❑ 创建集合
❑ 创建映射
❑ Promise.all()接收由期约组成的可迭代对象
❑ Promise.race()接收由期约组成的可迭代对象
❑ yield*操作符，在生成器中使用

如果对象原型链上的父类实现了 Iterable 接口，那这个对象也就实现了这个接口。

7.2.2 迭代器协议

迭代器 API 使用 next()方法在可迭代对象中遍历数据。next()方法返回的迭代器对象 IteratorResult 包含两个属性：done 和 value。done 是一个布尔值，表示是否还可以再次调用 next()取得下一个值；value 包含可迭代对象的下一个值（done 为 false）​，或者 undefined（done 为 true）​。done: true 状态称为“耗尽”​。

迭代器并不知道怎么从可迭代对象中取得下一个值，也不知道可迭代对象有多大。只要迭代器到达 done: true 状态，后续调用 next()就一直返回同样的值了：

let arr = ['foo']
let iter = arr[Symbol.iterator]()
console.log(iter.next()) // { value: 'foo', done: false }
console.log(iter.next()) // { value: undefined, done: true }
console.log(iter.next()) // { value: undefined, done: true }
console.log(iter.next()) // { value: undefined, done: true }

每个迭代器都表示对可迭代对象的一次性有序遍历。不同迭代器的实例相互之间没有联系，只会独立地遍历可迭代对象：

let arr = ['foo', 'bar']
let iter1 = arr[Symbol.iterator]()
let iter2 = arr[Symbol.iterator]()
console.log(iter1.next()) // { value: 'foo', done: false }
console.log(iter2.next()) // { value: 'foo', done: false }
console.log(iter2.next()) // { value: 'bar', done: false }
console.log(iter1.next()) // { value: 'bar', done: false }

迭代器并不与可迭代对象某个时刻的快照绑定，而仅仅是使用游标来记录遍历可迭代对象的历程。如果可迭代对象在迭代期间被修改了，那么迭代器也会反映相应的变化：

let arr = ['foo', 'baz']
let iter = arr[Symbol.iterator]()
console.log(iter.next()) // { value: 'foo', done: false }
// 在数组中间插入值
arr.splice(1, 0, 'bar')
console.log(iter.next()) // { value: 'bar', done: false }
console.log(iter.next()) // { value: 'baz', done: false }
console.log(iter.next()) // { value: undefined, done: true }

注意

迭代器维护着一个指向可迭代对象的引用，因此迭代器会阻止垃圾回收程序回收可迭代对象。

“迭代器”的概念有时候容易模糊，因为它可以指通用的迭代，也可以指接口，还可以指正式的迭代器类型。下面的例子比较了一个显式的迭代器实现和一个原生的迭代器实现。

// 这个类实现了可迭代接口（Iterable）
// 调用默认的迭代器工厂函数会返回
// 一个实现迭代器接口（Iterator）的迭代器对象
class Foo {
  [Symbol.iterator]() {
    return {
      next() {
        return { done: false, value: 'foo' }
      }
    }
  }
}
let f = new Foo()
// 打印出实现了迭代器接口的对象
console.log(f[Symbol.iterator]()) // { next: f() {} }
// Array类型实现了可迭代接口（Iterable）
// 调用Array类型的默认迭代器工厂函数
// 会创建一个ArrayIterator的实例
let a = new Array()
// 打印出ArrayIterator的实例
console.log(a[Symbol.iterator]()) // Array Iterator {}

7.2.3 自定义迭代器

与 Iterable 接口类似，任何实现 Iterator 接口的对象都可以作为迭代器使用。下面这个例子中的 Counter 类只能被迭代一定的次数：

class Counter {
  // Counter的实例应该迭代limit次
  constructor(limit) {
    this.count = 1
    this.limit = limit
  }
  next() {
    if (this.count <= this.limit) {
      return { done: false, value: this.count++ }
    } else {
      return { done: true, value: undefined }
    }
  }
  [Symbol.iterator]() {
    return this
  }
}
let counter = new Counter(3)
for (let i of counter) {
  console.log(i) // 1, 2, 3
}

这个类实现了 Iterator 接口，但不理想。这是因为它的每个实例只能被迭代一次：

for (let i of counter) {
  console.log(i) // 1, 2, 3
}
for (let i of counter) {
  console.log(i) // (nothing logged)
}

为了让一个可迭代对象能够创建多个迭代器，必须每创建一个迭代器就对应一个新计数器。为此，可以把计数器变量放到闭包里，然后通过闭包返回迭代器：

class Counter {
  constructor(limit) {
    this.limit = limit
  }
  [Symbol.iterator]() {
    let count = 1,
      limit = this.limit
    return {
      next() {
        if (count <= limit) {
          return { done: false, value: count++ }
        } else {
          return { done: true, value: undefined }
        }
      }
    }
  }
}
let counter = new Counter(3)
for (let i of counter) {
  console.log(i) // 1, 2, 3
}
for (let i of counter) {
  console.log(i) // 1, 2, 3
}

7.2.4 提前终止迭代器

可选的 return()方法用于指定在迭代器提前关闭时执行的逻辑。return()方法必须返回一个有效的 IteratorResult 对象。简单情况下，可以只返回{done: true }。

class Counter {
  constructor(limit) {
    this.limit = limit
  }
  [Symbol.iterator]() {
    let count = 1,
      limit = this.limit
    return {
      next() {
        if (count <= limit) {
          return { done: false, value: count++ }
        } else {
          return { done: true }
        }
      },
      return() {
        console.log('Exitingearly')
        return { done: true }
      }
    }
  }
}
let counter1 = new Counter(5)
for (let i of counter1) {
  if (i > 2) {
    break
  }
  console.log(i) // 1, 2, 'Exitingearly'
}
let counter2 = new Counter(5)
try {
  for (let i of counter2) {
    if (i > 2) {
      throw 'err'
    }
    console.log(i) // 1, 2, 'Exitingearly'
  }
} catch (e) {}
let counter3 = new Counter(5)
let [a, b] = counter3 // 'Exitingearly'

如果迭代器没有关闭，则还可以继续从上次离开的地方继续迭代。比如，数组的迭代器就是不能关闭的：

let a = [1, 2, 3, 4, 5]
let iter = a[Symbol.iterator]()
for (let i of iter) {
  console.log(i) // 1, 2, 3
  if (i > 2) {
    break
  }
}
for (let i of iter) {
  console.log(i) // 4, 5
}

因为 return()方法是可选的，所以并非所有迭代器都是可关闭的。要知道某个迭代器是否可关闭，可以测试这个迭代器实例的 return 属性是不是函数对象。不过，仅仅给一个不可关闭的迭代器增加这个方法并不能让它变成可关闭的。这是因为调用 return()不会强制迭代器进入关闭状态。即便如此，return()方法还是会被调用。

let a = [1, 2, 3, 4, 5]
let iter = a[Symbol.iterator]()
iter.return = function () {
  console.log('Exitingearly')
  return { done: true }
}
for (let i of iter) {
  console.log(i) // 1, 2, 3, 'Exitingearly'
  if (i > 2) {
    break
  }
}
for (let i of iter) {
  console.log(i) // 4, 5
}

7.3 生成器

生成器是 ECMAScript 6 新增的一个极为灵活的结构，拥有在一个函数块内暂停和恢复代码执行的能力。使用生成器可以自定义迭代器和实现协程。

7.3.1 生成器基础

生成器的形式是一个函数，函数名称前面加一个星号（*）表示它是一个生成器。只要是可以定义函数的地方，就可以定义生成器。标识生成器函数的星号不受两侧空格的影响。

// 生成器函数声明
function* generatorFn() {}
// 生成器函数表达式
let generatorFn = function* () {}
// 作为对象字面量方法的生成器函数
let foo = {
  *generatorFn() {}
}
// 作为类实例方法的生成器函数
class Foo {
  *generatorFn() {}
}
// 作为类静态方法的生成器函数
class Bar {
  static *generatorFn() {}
}

注意

箭头函数不能用来定义生成器函数。

调用生成器函数会产生一个生成器对象。生成器对象一开始处于暂停执行（suspended）的状态。与迭代器相似，生成器对象也实现了 Iterator 接口，因此具有 next()方法。调用这个方法会让生成器开始或恢复执行。

function* generatorFn() {}
const g = generatorFn()
console.log(g) // generatorFn {<suspended>}
console.log(g.next) // f next() { [native code] }

next()方法的返回值类似于迭代器，有一个 done 属性和一个 value 属性。函数体为空的生成器函数中间不会停留，调用一次 next()就会让生成器到达 done: true 状态。

value 属性是生成器函数的返回值，默认值为 undefined，可以通过生成器函数的返回值指定。生成器函数只会在初次调用 next()方法后开始执行。

function* generatorFn() {
  return 'foo'
}
let generatorObject = generatorFn()
console.log(generatorObject) // generatorFn {<suspended>}
console.log(generatorObject.next()) // { value: 'foo', done: true }

生成器对象实现了 Iterable 接口，它们默认的迭代器是自引用的：

function* generatorFn() {}
console.log(generatorFn) // f* generatorFn() {}
console.log(generatorFn()[Symbol.iterator]) // f [Symbol.iterator]() {native code}
console.log(generatorFn()) // generatorFn {<suspended>}
console.log(generatorFn()[Symbol.iterator]()) // generatorFn {<suspended>}
const g = generatorFn()
console.log(g === g[Symbol.iterator]()) // true

7.3.2 通过 yield 中断执行

yield 关键字可以让生成器停止和开始执行，也是生成器最有用的地方。生成器函数在遇到 yield 关键字之前会正常执行。遇到这个关键字后，执行会停止，函数作用域的状态会被保留。停止执行的生成器函数只能通过在生成器对象上调用 next()方法来恢复执行。

function* generatorFn() {
  yield
}
let generatorObject = generatorFn()
console.log(generatorObject.next()) // { value: undefined, done: false }
console.log(generatorObject.next()) // { value: undefined, done: true }

此时的 yield 关键字有点像函数的中间返回语句，它生成的值会出现在 next()方法返回的对象里。通过 yield 关键字退出的生成器函数会处在 done: false 状态；通过 return 关键字退出的生成器函数会处于 done: true 状态。

function* generatorFn() {
  yield 'foo'
  yield 'bar'
  return 'baz'
}
let generatorObject = generatorFn()
console.log(generatorObject.next()) // { value: 'foo', done: false }
console.log(generatorObject.next()) // { value: 'bar', done: false }
console.log(generatorObject.next()) // { value: 'baz', done: true }

生成器函数内部的执行流程会针对每个生成器对象区分作用域。在一个生成器对象上调用 next()不会影响其他生成器：

function* generatorFn() {
  yield 'foo'
  yield 'bar'
  return 'baz'
}
let generatorObject1 = generatorFn()
let generatorObject2 = generatorFn()
console.log(generatorObject1.next()) // { value: 'foo', done: false }
console.log(generatorObject2.next()) // { value: 'foo', done: false }
console.log(generatorObject2.next()) // { value: 'bar', done: false }
console.log(generatorObject1.next()) // { value: 'bar', done: false }

yield 关键字只能在生成器函数内部使用，用在其他地方会抛出错误。类似函数的 return 关键字，yield 关键字必须直接位于生成器函数定义中，出现在嵌套的非生成器函数中会抛出语法错误。

1．生成器对象作为可迭代对象

如果把生成器对象当成可迭代对象，那么使用起来会更方便。

function* nTimes(n) {
  while (n--) {
    yield
  }
}
for (let _ of nTimes(3)) {
  console.log('foo') // 'foo', 'foo', 'foo'
}

2．使用 yield 实现输入和输出

除了可以作为函数的中间返回语句使用，yield 关键字还可以作为函数的中间参数使用。上一次让生成器函数暂停的 yield 关键字会接收到传给 next()方法的第一个值。这里有个地方不太好理解——第一次调用 next()传入的值不会被使用，因为这一次调用是为了开始执行生成器函数：

function* generatorFn(initial) {
  console.log(initial)
  console.log(yield)
  console.log(yield)
}
let generatorObject = generatorFn('foo')
generatorObject.next('bar') // 'foo'
generatorObject.next('baz') // 'baz'
generatorObject.next('qux') // 'qux'

yield 关键字可以同时用于输入和输出。

function* generatorFn() {
  return yield 'foo'
}
let generatorObject = generatorFn()
console.log(generatorObject.next()) // { value: 'foo', done: false }
console.log(generatorObject.next('bar')) // { value: 'bar', done: true }

yield 关键字并非只能使用一次。

function* nTimes(n) {
  let i = 0
  while (n--) {
    yield i++
  }
}
for (let x of nTimes(3)) {
  console.log(x) // 0 1 2
}

3．产生可迭代对象

可以使用星号增强 yield 的行为，让它能够迭代一个可迭代对象，从而一次产出一个值。yield 星号两侧的空格不影响其行为。

// 等价的generatorFn：
// function* generatorFn() {
//   for (const x of [1, 2, 3]) {
//     yield x
//   }
// }
function* generatorFn() {
  yield* [1, 2, 3]
}
let generatorObject = generatorFn()
for (const x of generatorFn()) {
  console.log(x) // 1, 2, 3
}

4．使用 yield* 实现递归算法

function* nTimes(n) {
  if (n > 0) {
    yield* nTimes(n - 1)
    yield n - 1
  }
}
for (const x of nTimes(3)) {
  console.log(x) // 0, 1, 2
}

7.3.3 生成器作为默认迭代器

因为生成器对象实现了 Iterable 接口，而且生成器函数和默认迭代器被调用之后都产生迭代器，所以生成器格外适合作为默认迭代器。

class Foo {
  constructor() {
    this.values = [1, 2, 3]
  }
  *[Symbol.iterator]() {
    yield* this.values
  }
}
const f = new Foo()
for (const x of f) {
  console.log(x) // 1, 2, 3
}

7.3.4 提前终止生成器

与迭代器类似，生成器也支持“可关闭”的概念。一个实现 Iterator 接口的对象一定有 next()方法，还有一个可选的 return()方法用于提前终止迭代器。生成器对象除了有这两个方法，还有第三个方法：throw()。

function* generatorFn() {}
const g = generatorFn()
console.log(g) // generatorFn {<suspended>}
console.log(g.next) // f next() { [native code] }
console.log(g.return) // f return() { [native code] }
console.log(g.throw) // f throw() { [native code] }

return()和 throw()方法都可以用于强制生成器进入关闭状态。

1．return()

return()方法会强制生成器进入关闭状态。提供给 return()方法的值，就是终止迭代器对象的值。与迭代器不同，所有生成器对象都有return()方法，只要通过它进入关闭状态，就无法恢复了。后续调用 next()会显示 done: true 状态，而提供的任何返回值都不会被存储或传播

function* generatorFn() {
  for (const x of [1, 2, 3]) {
    yield x
  }
}
const g = generatorFn()
console.log(g) // generatorFn {<suspended>}
console.log(g.return(4)) // { value: 4, done: true }
console.log(g) // generatorFn {<closed>}
console.log(g.next()) // { value: undefined, done: true }

for-of 循环等内置语言结构会忽略状态为 done: true 的 IteratorObject 内部返回的值。

2．throw()

throw()方法会在暂停的时候将一个提供的错误注入到生成器对象中。如果错误未被处理，生成器就会关闭：

function* generatorFn() {
  for (const x of [1, 2, 3]) {
    yield x
  }
}
const g = generatorFn()
console.log(g) // generatorFn {<suspended>}
try {
  g.throw('foo')
} catch (e) {
  console.log(e) // 'foo'
}
console.log(g) // generatorFn {<closed>}

不过，假如生成器函数内部处理了这个错误，那么生成器就不会关闭，而且还可以恢复执行。错误处理会跳过对应的 yield，因此在这个例子中会跳过一个值。

function* generatorFn() {
  for (const x of [1, 2, 3]) {
    try {
      yield x
    } catch (e) {}
  }
}
const g = generatorFn()
console.log(g.next()) // { value: 1, done: false }
g.throw('foo')
console.log(g.next()) // { value: 3, done: false }

如果生成器对象还没有开始执行，那么调用 throw()抛出的错误不会在函数内部被捕获，因为这相当于在函数块外部抛出了错误。（throw 方法抛出的错误要被内部捕获，前提是必须至少执行过一次 next 方法。）

function* gen() {
  try {
    yield 1
  } catch (e) {
    console.log('内部捕获')
  }
}

var g = gen()
g.throw(1)