JavaScript（红宝书）（七）

7.迭代器与生成器

 理解迭代
 迭代器模式
 生成器

1.理解迭代：

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

迭代需要什么：迭代会在一个有序集合上进行。（“有序”可以理解为集合中所有项都可以按照既定的顺序被遍历 到，特别是开始和结束项有明确的定义。）

2.迭代器模式：

可以把有些结构称为“可迭 代对象”（iterable），因为它们实现了正式的 Iterable 接口，而且可以通过迭代器 Iterator 消费。

可迭代对象：可以把可迭代对象理解成数组或集合这样的集合类型的对 象。它们包含的元素都是有限的，而且都具有无歧义的遍历顺序

任何实现了迭代器接口的数据结构都可以被实现了迭代器接口的结构消费掉。迭代器无须了解与其关联的可迭代对象的结构，只需要知道如何取得连续的 值。

【1】可迭代协议：支持迭代的自我识别能力和创建实现 Iterator 接口的对象的能力。

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

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

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

【2】迭代器协议：

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

迭代器对象IteratorResult 包含两个属性：done 和 value，done 是一个布 尔值，表示是否还可以再次调用 next()取得下一个值；value 包含可迭代对象的下一个值（done 为 false），或者 undefined（done 为 true）

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

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

【3】自定义迭代器：

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

只要实现了迭代器的接口就可以被原生的一些操作特性解析。

为了使得一个可迭代对象能够创建出多个迭代器，必须为每一个迭代器创建一个新计数器，这时我们就不能调用对象本身的this属性来操作了，因为这会引起操作变量交叠。

此时可以引用闭包，使得每一个返回的对象都拿到一个闭包隐藏的变量的句柄。达到不断初始化新值和计数的目的。

【4】提前终止迭代器：

 for-of 循环通过 break、continue、return 或 throw 提前退出//内置语言结构在发现还有更多值可以迭代，但不会消费这些值时，会自动调用 return()方法

 解构操作并未消费所有值。

部分迭代器不可关闭。比如，数组的迭代器就是不能关 闭的

---

3.生成器：

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

【1】：生成器基础 生成器的形式是一个函数，函数名称前面加一个星号（*）表示它是一个生成器。

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

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

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

function* generatorFn() {
 return 'foo';//打印
} 
console.log(generatorObject.next()); // 获得如下结果{ done: true, value: 'foo' }

生成器对象实现了 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 

【2】通过yield中断执行：（生成器函数就像工厂函数般产生不同生成器对象）

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

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

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

​ //使用；

1 生成器对象可以用于迭代（类似python的循环）

function* nTimes(n) {
 while(n--) {
 yield;
 }
} //举例 这个生成器函数可以调用n+1次next

2 使用 yield 实现输入和输出

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

function* generatorFn(initial) {
 console.log(initial);
 console.log(yield);
 console.log(yield);
}
let generatorObject = generatorFn('foo');//传入foo参数
generatorObject.next('bar'); // foo 第一次调用沿用初始化传入参数
generatorObject.next('baz'); // baz 传参替换yield语句
generatorObject.next('qux'); // qux 
---
function* generatorFn() {
 return yield 'foo';
}
let generatorObject = generatorFn();
console.log(generatorObject.next()); // { done: false, value: 'foo' }
console.log(generatorObject.next('bar')); // { done: true, value: 'bar' }

得到上一步的步骤是：

​ 因为函数必须对整个表达式求值才能确定要返回的值，所以它在遇到 yield 关键字时暂停执行并 计算出要产生的值：“foo”。下一次调用 next()传入了"bar"，作为交给同一个 yield 的值。然后这 个值被确定为本次生成器函数要返回的值。

3 产生可迭代对象

可以使用星号增强 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 

关于yield*的值（之前讨论过yield的值）：它的值是关联迭代器返回 done: true 时的 value 属性

​ yield的值取决于next（除了第一次）内传入的参数，在生成器内部打印或者中断返回打印next（）的返回值会得到传入的参数。

​ 关于yield*的值 如果要返回它的值或者打印它的值（只会打印一次 因为它的迭代过程需要完全求出 才能将结果与其他语句结合）。

function* generatorFn() {
 console.log('iter value:', yield* [1, 2, 3]);
} //普通迭代器跟随yd*会返回其最后迭代得到的undefined
//对于生成器函数产生的迭代器来说，这个值就是生成器函数返回的值：

4 使用 yield*实现递归算法

function* nTimes(n) {
 if (n > 0) {
 yield* nTimes(n - 1);
 yield n - 1;
 }//迭代到首先到的语句是yield 0;
for (const x of nTimes(3)) {
 console.log(x);
}
// 0
// 1
// 2

【3】生成器作为默认迭代器

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

【4】提前终止生成器

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

1 return方法：return()方法会强制生成器进入关闭状态。提供给 return()方法的值，就是终止迭代器对象的值// generatorFn {<\closed>}

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

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

如果生成器对象还没有开始执行，那么调用 throw()抛出的错误不会在函数内部被 捕获，因为这相当于在函数块外部抛出了错误。

4.小结:

​ 迭代是一种所有编程语言中都可以看到的模式。ECMAScript 6 正式支持迭代模式并引入了两个新的 语言特性：迭代器和生成器。

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

【2】：生成器是一种特殊的函数，调用之后会返回一个生成器对象。生成器对象实现了 Iterable 接口， 因此可用在任何消费可迭代对象的地方。生成器的独特之处在于支持 yield 关键字，这个关键字能够 暂停执行生成器函数。使用 yield 关键字还可以通过 next()方法接收输入和产生输出。在加上星号之 后，yield 关键字可以将跟在它后面的可迭代对象序列化为一连串值。