[路飞]_红宝书学习笔记（六）生成器是一种特殊的函数，调用之后会返回一个生成器对象。生成器对象实现了 Iterable

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

生成器（Generators）

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

Generator Basics

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

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

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

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

value 属性是生成器函数的返回值，默认值为 undefined，可以通过生成器函数的yield 或 return指定返回值。

生成器函数只会在初次调用 next()方法后开始执行

function* generatorFn() { 
  console.log('foobar');
}
// 初次调用生成器函数并不会打印日志
let generatorObject = generatorFn();
generatorObject.next();// foobar

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

通过 yield 中断执行(Interrupting Execution with `yield`)

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

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

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

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

// 有效
function* validGeneratorFn() {
  yield
}

// 无效
function* invalidGeneratorFnA() {
  function a() {
    yield
  }
}

// 无效
function* invalidGeneratorFnB() {
  const b = () => {
    yield
  }
}

// 无效
function* invalidGeneratorFnC() {
  (() => {
    yield
  })()
}

生成器的用法

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

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

for (const x of generatorFn()) { 
  console.log(x); 
} // 1 // 2 // 3

使用yield实现输入和输出除了可以作为函数的中间返回语句使用，yield 关键字还可以作为函数的中间参数使用。

function* generatorFn(initial) {
  console.log(initial)
  console.log(yield)
  console.log(yield)
}

let generatorObject = generatorFn('foo')

generatorObject.next('bar')
generatorObject.next('baz')
generatorObject.next('qux')
// foo // baz // qux

function* generatorFn() {
  return yield 'foo'
}
let generatorObject = generatorFn()
console.log(generatorObject.next())
console.log(generatorObject.next('bar'))
// { done: false, value: 'foo' }
// 因为函数必须对整个表达式求值才能确定要返回的值，所以它在遇到 yield 关键字时暂停执行并 计算出要产生的值："foo"。下一次调用 next()传入了"bar"，作为交给同一个 yield 的值。然后这 个值被确定为本次生成器函数要返回的值。

产生可迭代对象可以使用星号增强 yield 的行为，让它能够迭代一个可迭代对象，从而一次产出一个值

// 等价的 generatorFn： 
// function* generatorFn() { 
// 		for (const x of [1, 2, 3]) { 
// 			yield x; 
// 		}
// } 
function* generatorFn() { yield* [1, 2, 3]; }

for (const x of generatorFn()) { console.log(x); }
// 1 // 2 // 3
// 因为 yield*实际上只是将一个可迭代对象序列化为一连串可以单独产出的值，所以这跟把 yield 放到一个循环里没什么不同。下面两个生成器函数的行为是等价的
function* generatorFnA() { 
  for (const x of [1, 2, 3]) {
    yield x; 
  }
}

for (const x of generatorFnA()) { console.log(x); } // 1 // 2 // 3

function* generatorFnB() { yield* [1, 2, 3]; }

for (const x of generatorFnB()) { console.log(x); } // 1 // 2 // 3

yield*的值是关联迭代器返回 done: true 时的 value 属性。对于普通迭代器来说，这个值是 undefined;对于生成器函数产生的迭代器来说，这个值就是生成器函数返回的值。

function* generatorFn() { console.log('iter value:', yield* [1, 2, 3]); }

for (const x of generatorFn()) { console.log('value:', x); }
// value: 1 // value: 2 // value: 3 // iter value: undefined

function* innerGeneratorFn() { 
  yield 'foo'; 
  return 'bar'; 
} 
function* outerGeneratorFn(genObj) {
console.log('iter value:', yield* innerGeneratorFn()); 
}

for (const x of outerGeneratorFn()) {
  console.log('value:', x); 
} 
// value: foo // iter value: bar

使用 yield*实现递归算法

// 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

生成器作为默认迭代器（Using a Generator as the Default Iterator）

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

提前终止生成器（Early Termination of Generators）

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

return() return()方法会强制生成器进入关闭状态。提供给 return()方法的值，就是终止迭代器对象的值：

function* generatorFn() { for (const x of [1, 2, 3]) { yield x; } }

const g = generatorFn();

console.log(g); // generatorFn {<suspended>} 
console.log(g.return(4));// { done: true, value: 4 }
console.log(g);// generatorFn {<closed>}

与迭代器不同，所有生成器对象都有 return()方法，只要通过它进入关闭状态，就无法恢复了。后续调用 next()会显示 done: true 状态，而提供的任何返回值都不会被存储或传播. for-of 循环等内置语言结构会忽略状态为 done: true 的 IteratorObject 内部返回的值。

function* generatorFn() { 
  for (const x of [1, 2, 3]) { 
    yield x; 
  }
}

const g = generatorFn();
for (const x of g) { 
  if (x > 1) {
    g.return(4);
  }
  console.log(x);
} // 1 // 2

throw()

throw()方法会在暂停的时候将一个提供的错误注入到生成器对象中。如果错误未被处理，生成器就会关闭. 假如生成器函数内部处理了这个错误，那么生成器就不会关闭，而且还可以恢复执行。错误处理会跳过对应的 yield.

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>}



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

const g3 = generatorFn2(); 
g3.throw('foo'); // ERROR: Uncaught foo
console.log(g3.next()); // 这段代码不会执行
// 注意： 如果生成器对象还没有开始执行，那么调用 throw()抛出的错误不会在函数内部被捕获，因为这相当于在函数块外部抛出了错误。

Summary

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

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