【JavaScript】生成器

每個生成器函数都是一个GeneratorFunction对象，生成器函数由 function* 语法编写，每次调用生成器函数都会返回一个新的Generator对象，该对象符合迭代协议（包含可迭代协议和迭代器协议）。调用生成器函数时不执行任何代码，而是返回一种称为生成器的特殊迭代器。

1.GeneratorFunction对象

• GeneratorFunction对象为生成器函数提供了方法。在JavaScript中，每个生成器函数实际上都是一个GeneratorFunction对象。

• GeneratorFunction是Function的子类，它不是全局对象，可以通过以下代码获取：
  const GeneratorFunction = function *(){}.constructor；

//Function语法：
new Function(arg0, arg1, /* …, */ argN, functionBody)
Function (arg1, arg2, /* …, */ argN, functionBody)

//GeneratorFunction语法：
//GeneratorFunction不是全局可用的，要先获取到，在使用
const GeneratorFunction = function* () {}.constructor;
new GeneratorFunction(arg1, arg2, /* …, */ argN, functionBody)
GeneratorFunction(arg1, arg2, /* …, */ argN, functionBody)

2.Generator对象

• Generator对象由生成器函数返回，并且它符合可迭代协议和迭代器协议。
• Generator是隐藏类Iterator的子类。
• Generator 构造函数并不是全局可用的，必须从生成器函数返回。
• Generator对象符合可迭代协议，则可进行for…of循环、展开语法、解构；符合迭代器协议，则该对象有一个**next()**方法，next()方法返回iteratorResult对象（{done：false,value:xxx}）

3. function*表达式

function*关键字可以在表达式内部定义一个生成器函数。

//语法：
function* [name]([param1[,param2[param3…]]]){
	//statements
}
//name：函数名。声明匿名函数时可省略。
//示例：
const foo = function*(){
	yield 1;
	yield 2;
}

4.function* 声明

function*声明创建一个绑定到给定名称的新生成器函数。

//语法：
function* name(param1){…}
function* name(param1,param2){…}
function* name(param1,…,paramN){…}
//示例：
function* generator(i){
	yield i;
	yield i+10;
}

注意：
箭头函数不能用来定义生成器函数。
function和*是两个单独的标记，它们之间可以用空白或换行符分隔。

function*声明的行为与function声明类似，它们会被提升到其作用域的顶部，并且可以在当前作用域的任何位置被调用，且只能在特定的上下文中被重新声明。

5.yield

yield关键字用来暂停和恢复生成器函数。
语法：
[rv] = yield [expression];
expression:定义 通过迭代器协议从生成器函数返回的值。如果省略，则返回undefined.
rv:返回传递给生成器的next()方法的可选值，以恢复其执行。

yield实际返回一个IteratorResult对象，{done：true/false,value:xxx}
一旦遇到yield表达式，生成器的代码将被暂停运行，直到生成器的 next()方法被调用。每次调用next()方法时，生成器都会恢复执行，直到达到以下某个值：
1）yield
2）throw 从生成器中抛出异常
3）达到生成器的结尾，这时生成器执行结束，返回{done：true，value:undefined}
4）达到return语句，这时生成器执行结束，返回IteratorResult对象，value值为return返回的值（没有则为undefined），done为true,{done:true,value://return 的值}

6.yield*

yield* 表达式用于委托给另一个generator或可迭代对象。
语法：
yield* [[expression]]
expression返回一个可迭代对象的表达式。
实例：
1.委托给其他生成器

function* g1() {
  yield 2;
  yield 3;
  yield 4;
}

function* g2() {
  yield 1;
  yield* g1();
  yield 5;
}
var iterator = g2();
//iterator多次执行iterator.next().value ，依次返回：1,2,3,4,5,undefined

2.委托给其他可迭代对象

function* g3() {
  yield* [1, 2];
  yield* "34";
  yield* arguments;
}

var iterator = g3(5, 6);
//iterator多次执行iterator.next().value ，依次返回：1,2,”3”,”4”,5,6,undefined

yield*是一个表达式，所以它会有自己的值。

总结

function*声明创建一个GeneratorFunction对象。每次调用生成器函数时，它都会返回一个新的生成器（Generator对象），该对象符合迭代器协议。当迭代器的next()方法被调用时，生成器函数的主体会被执行，直到遇到第一个yield表达式，该表达式指定了迭代器要返回的值，或者用yield*委托给另一个生成器函数。next()方法返回IteratorResult对象，其value属性包含了yield表达式的值，done返回布尔值表示生成器是否已经返回最后一个值。如果next()方法带有参数，那么它会恢复生成器函数的执行，并用参数替代执行的yield表达式。

const sum = new Function("a", "b", "return a +b");
console.log(sum.toString());
console.log(sum(1, 2)); //3

const GeneratorFunction = function* () {}.constructor;
const foo = new GeneratorFunction(`
    yield 1;
    yield 2;
    yield 3;
`);
let iterator = foo();
console.log(iterator.next()); //{ value: 1, done: false }
console.log(iterator.next()); //{ value: 2, done: false }
console.log(iterator.next()); //{ value: 3, done: false }
console.log(iterator.next()); //{ value: undefined, done: true }

let str = "";
for (let val of foo()) {
  str = str + val;
}
console.log(str); //123

//Function*声明
function* foo1() {
  yield "a";
  yield "b";
  yield "c";
}
//Fucntion* 表达式
const foo2 = function* () {
  yield "a1";
  yield "b1";
  yield "c1";
};

//foo,foo1,foo2定义的方式不同，但是类型一致，使用发方法一致