「这是我参与11月更文挑战的第7天，活动详情查看：2021最后一次更文挑战」

迭代器与生成器（1）（Iterators and Generators）

在 ECMAScript 较早的版本中，执行迭代必须使用循环或其他辅助结构。随着代码量增加，代码会变得越发混乱。很多语言都通过原生语言结构解决了这个问题，开发者无须事先知道如何迭代就能实现迭代操作。这个解决方案就是迭代器模式（the iterator pattern）。Python、Java、C++，还有其他很多语言都对这个模式提供了完备的支持。JavaScript 在 ECMAScript 6 以后也支持了迭代器模式。

在ES6推出迭代器（Iterator）之前，我们一般用循环来执行迭代。最简单的例子如下

for (let i = 1; i <= 10; ++i) {
console.log(i);
}

通过这种循环来执行迭代并不理想，有以下缺点

迭代之前需要事先知道如何使用数据结构。（Iterating through the data structure requires a specific knowledge of how to use the data structure.）数组通过[]操作符来取得特定索引位置上的项，这种情况不适用于所有数据结构。
遍历顺序并不是数据结构固有的。（The order of traversal is not inherent to the data structure.）通过递增索引来访问数据是特定于数组类型的方式，并不适用于其他具有隐式顺序的数据结构。

迭代器模式（the iterator pattern）

迭代器模式（特别是在 ECMAScript 这个语境下）描述了一个方案，即可以把有些结构称为“可迭代对象”（iterable），因为它们实现了正式的Iterable 接口，而且可以通过迭代器 Iterator 消费（consume）。

迭代器（iterator）是按需创建的一次性对象。每个迭代器都会关联一个可迭代对象，而迭代器会暴露迭代其关联可迭代对象的 API。迭代器无须了解与其关联的可迭代对象的结构，只需要知道如何取得连续的值。这种概念上的分离正是 Iterable 和 Iterator 的强大之处。

可迭代对象是一种抽象的说法。基本上，可以把可迭代对象理解成数组或集合这样的集合类型的对象。不过，可迭代对象不一定是集合对象，也可以是仅仅具有类似数组行为的其他数据结构。

可迭代协议（The Iterable Protocol）、

实现 Iterable 接口（可迭代协议）要求同时具备两种能力：

支持迭代的自我识别能力
创建实现 Iterator 接口的对象的能力。

Implementing the Iterable interface requires both the capability to self-identify as supporting iteration and the capability to create an object that implements the Iterator interface.

在 ECMAScript 中，这意味着必须暴露一个属性作为“默认迭代器”，而且这个属性必须使用特殊的 Symbol.iterator 作为键。这个默认迭代器属性必须引用一个迭代器工厂函数（iterator factory function），调用这个工厂函数必须返回一个新迭代器。

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

Strings
Arrays
Maps
Sets
The arguments object
Some DOM collection types like NodeList

没有实现Iterable接口的类型

Booleans
Numbers
Objects

let num = 1;

let obj = {};

let bool = true;

// 这两种类型没有实现迭代器工厂函数
console.log(num[Symbol.iterator]); // undefined
console.log(obj[Symbol.iterator]); // undefined
console.log(bool[Symbol.iterator]); // undefined

let str = 'abc';

let arr = ['a', 'b', 'c'];

let map = new Map().set('a', 1).set('b', 2).set('c', 3);

let set = new Set().add('a').add('b').add('c');

let els = document.querySelectorAll('div');

// 这些类型都实现了迭代器工厂函数 
console.log(str[Symbol.iterator]); // f values() { [native code] }
console.log(arr[Symbol.iterator]); // f values() { [native code] } 
console.log(map[Symbol.iterator]); // f values() { [native code] } 
console.log(set[Symbol.iterator]); // f values() { [native code] } 
console.log(els[Symbol.iterator]); // f values() { [native code] }
// 调用这个工厂函数会生成一个迭代器 
console.log(str[Symbol.iterator]()); // StringIterator {}
console.log(arr[Symbol.iterator]()); // ArrayIterator {} 
console.log(map[Symbol.iterator]()); // MapIterator {} 
console.log(set[Symbol.iterator]()); // SetIterator {} 
console.log(els[Symbol.iterator]()); // ArrayIterator {}

在实际写代码的过程中，我们不需要显示调用这个工厂函数来生成迭代器。实现可迭代协议的所有类型都会自动兼容接收可迭代对象的任何语言特性。可迭代对象的原生语言特性包括：

for...of loop
Array destructuring 数组解构
The spread operator 扩展操作符
Array.from()
Set construction 创建集合
Map construction 创建映射
Promise.all(), which expects an iterable of promises
Promise.race(), which expects an iterable of promises
The yield*operator, used in generators

这些原生语言结构会在后台调用这个提供的可迭代对象的工厂函数，从而创建一个迭代器：

let arr = ['foo', 'bar', 'baz'];

// Array destructuring
let [a, b, c] = arr;
console.log(a, b, c);

// Spread operator
let arr2 = [...arr]; // foo, bar, baz
console.log(arr2); // ['foo', 'bar', 'baz']

// Array.from() 
let arr3 = Array.from(arr); console.log(arr3); // ['foo', 'bar', 'baz']

// Map constructor 
let pairs = arr.map((x, i) => [x, i]); 
console.log(pairs); // [['foo', 0], ['bar', 1], ['baz', 2]] 
let map = new Map(pairs);
console.log(map); // Map(3) { 'foo'=>0, 'bar'=>1, 'baz'=>2 }

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

class FooArray extends Array {}
let fooArr = new FooArray('foo', 'bar', 'baz');
for (let el of fooArr) { console.log(el); } // foo // bar // baz

迭代器协议（The Iterator Protocol）

迭代器是一种一次性使用的对象，用于迭代与其关联的可迭代对象。迭代器 API 使用 next()方法在可迭代对象中遍历数据。每次成功调用 next()，都会返回一个 IteratorResult 对象，其中包含迭代器返回的下一个值。若不调用 next()，则无法知道迭代器的当前位置。

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

// 可迭代对象

let arr = ['foo', 'bar'];

// 迭代器工厂函数
console.log(arr[Symbol.iterator]); // f values() { [native code] }

// 迭代器
let iter = arr[Symbol.iterator]();

console.log(iter); // ArrayIterator {}

// 执行迭代
console.log(iter.next()); // { done: false, value: 'foo' } 
console.log(iter.next()); // { done: false, value: 'bar' }
console.log(iter.next()); // { done: true, value: undefined }

迭代器的特性

迭代器并不知道怎么从可迭代对象中取得下一个值，也不知道可迭代对象有多大。只要迭代器到达 done: true 状态，后续调用 next()就一直返回同样的值了
每个迭代器都表示对可迭代对象的一次性有序遍历。不同迭代器的实例相互之间没有联系，只会独立地遍历可迭代对象
迭代器并不与可迭代对象某个时刻的快照绑定，而仅仅是使用游标来记录遍历可迭代对象的历程。如果可迭代对象在迭代期间被修改了，那么迭代器也会反映相应的变化(An iterator is not bound to a snapshot of the iterable; it merely uses a cursor to track its progress through the iterable. If the iterable is mutated during iteration, the iterator will incorporate the changes)

let arr = ['foo', 'baz'];

let iter = arr[Symbol.iterator]();

console.log(iter.next()); // { done: false, value: 'foo' }

// Insert value in the middle of array 
arr.splice(1, 0, 'bar');

console.log(iter.next()); // { done: false, value: 'bar' }
console.log(iter.next()); // { done: false, value: 'baz' }
console.log(iter.next()); // { done: false, value: 'baz' }

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

“迭代器”的概念有时候容易模糊，因为它可以指通用的迭代，也可以指接口，还可以指正式的迭代器类型。

The term “iterator” can be somewhat nebulous because it refers to a generalized iteration concept, an interface, and formal iterator-type classes.

自定义迭代器（Custom Protocol Definition）

与 Iterable接口类似，任何实现 Iterator 接口的对象都可以作为迭代器使用。

class Counter {
  // Counter 的实例应该迭代 limit 次
  constructor(limit) {
    this.limit = limit
  }
  next() {
    let count = 1,
				limit = this.limit;
    if (count <= limit) {
      return { done: false, value: 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 接口，但不理想。这是因为它的每个实例只能被迭代一次。

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

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

提前终止迭代器（Early Termination of Iterators）

可选的 return()方法用于指定在迭代器提前关闭时执行的逻辑。执行迭代的结构在想让迭代器知道它不想遍历到可迭代对象耗尽时，就可以“关闭”迭代器。可能的情况包括：

for-of 循环通过 break、continue、return 或 throw 提前退出；
解构操作并未消费所有值。

return()方法必须返回一个有效的 IteratorResult 对象。简单情况下，可以只返回{ done: true }。

如下面的代码所示，内置语言结构在发现还有更多值可以迭代，但不会消费这些值时，会自动调用 return()方法。

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 }
        }
      },
      return() {
        console.log('Exiting early')
        return { done: true }
      },
    }
  }
}

let counter1 = new Counter(5)

for (let i of counter1) {
  if (i > 2) {
    break
  }
  console.log(i)
}
// 1 // 2 // Exiting early
let counter2 = new Counter(5)

try {
  for (let i of counter2) {
    if (i > 2) {
      throw 'err'
    }
    console.log(i)
  }
} catch (e) {}
// 1 // 2 // Exiting early

let counter3 = new Counter(5);

let [a, b] = counter3; 
// Exiting early

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

let a = [1, 2, 3, 4, 5]

let iter = a[Symbol.iterator]()

for (let i of iter) {
  console.log(i)
  if (i > 2) {
    break
  }
} // 1 // 2 // 3

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('Exiting early')
  return { done: true }
}

for (let i of iter) {
  console.log(i)
  if (i > 2) {
    break
  }
} // 1 // 2 // 3

for (let i of iter) {
  console.log(i)
} // 4 // 5

迭代器内容小结（Summary）

迭代器是一个可以由任意对象实现的接口，支持连续获取对象产出的每一个值。任何实现 Iterable 接口的对象都有一个 Symbol.iterator 属性，这个属性引用默认迭代器。默认迭代器就像一个迭代器工厂，也就是一个函数，调用之后会产生一个实现 Iterator 接口的对象。

迭代器必须通过连续调用 next()方法才能连续取得值，这个方法返回一个 IteratorObject。这个对象包含一个 done 属性和一个 value 属性。前者是一个布尔值，表示是否还有更多值可以访问；后者包含迭代器返回的当前值。这个接口可以通过手动反复调用 next()方法来消费，也可以通过原生消费者，比如 for-of 循环来自动消费。可选的return()方法用于指定在迭代器提前关闭时执行的逻辑。

[路飞]_红宝书学习笔记（五）