Generator & yield
开局官宣：sec-generatoryield，这是对yield的介绍。
同样巴拉巴拉列了9条，将以上链接中的说明简化成3条：
1. 在GeneratorFunction内，当遇到yield关键字的时候，先将执行上下文设置为yield之后的表达式进行执行，并且将该表达式返回值作为当前迭代的结果；
2. 将gen上下文从上下文堆栈中移除，将上级(gen之外)上下文(依次)恢复为当前执行的上下文，此过程中需设置gen上下文的评估状态，以便在上下文恢复时(下一次调用.next)继续操作迭代；
3. 通过.next方法依次执行迭代器。
先对上面3点有点印象，再来看看 Generator。
Generator 对象是通过 GeneratorFunction 执行返回的对象，具有可迭代的特性(迭代器协议定义了一种标准的方式来产生一个有限或无限序列的值)，关于迭代器详见"迭代器"。
GeneratorFunction => Generator GeneratorFunction.prototype next 返回迭代结果 return 传入参数作为迭代结果的value并返回该迭代项，并且结束Generator对象的迭代 throw 抛出错误值，并且结束Generator对象的迭代
每个迭代结果都包含 done 和 value ：
1. done 表示生成器是否被完成；
2. value 表示当前的值。
来个例子：
function* iterator1(){ console.log(1); yield '1'; console.log(2) yield *iterator2(); yield '2'; console.log(3); } function* iterator2(){ yield '3'; console.log(4); yield '4'; } function fn1(){ console.log(5) fn2(); console.log(6) } function fn2(){ console.log(7) var iter = iterator1(); console.log(iter.next()); console.log(iter.next()); console.log(iter.next()); console.log(8); console.log(iter.next()); console.log(iter.next()); console.log(9); } fn1(); /* * 输出顺序 * var iter = iterator1(); // before : 5 7 * console.log(iter.next()); // 1 {value:1,done:false} * console.log(iter.next()); // 2 {value:3,done:false} * console.log(iter.next()); // 4 {value:4,done:false} * console.log(8); // 8 * console.log(iter.next()); // {value:2,done:false} * console.log(iter.next()); // 3 {value:undefined,done:true} * console.log(9); // 9 after : 6 */
看输出顺序（多个Generator嵌套可看作为在外部Generator的某个索引位置插入内部Generator的元素作为迭代项）：
1. fn1被执行，首先输出 5；
2. 进入fn2，输出 7；
3. fn2中生成iter，并首次调用iter.next()，执行了iterator1里面第一个yield之前的console，输出 1，然后输出 {value: "1", done: false}；
4. 调用第二个iter.next()，进入iterator2中，输出 2，然后输出 {value:'3',done:false}；
5. 调用第三个iter.next()，还是进入iterator2，输出 4，然后输出 {value:'4',done:false}；
6. 调用fn2中的console.log(8)，输出 8；
7. 调用第四个iter.next()，这时候iterator2里面执行完了，继续执行iterator1的后续代码，输出 {value:2,done:false}；
8. 调用第五个iter.next()，继续iterator1的后续代码，输出 3，这时候iterator1的迭代结束，输出 {value:undefined,done:true}；
9. 调用fn2中的console.log(9)，输出 9；
10. 调用fn1中的console.log(6)，输出 6。
Generator的任务执行器
Generator通过.next方法来依次做迭代的执行，然而每次都需要手动写方法调用是个问题。然后便有了迭代任务的执行器，在执行器内将主动调用.next以执行迭代。
如下面例子：
function run(gen){ const task = gen(); // 定义一个对象用于存每个迭代结果，传入result.value 赋值到指定对象上 let result = task.next(); // 如果迭代未结束，则继续执行next()，获取下个迭代结果，以此类推... function step(){ if(!result.done){ result = task.next(result.value); step(); } } step(); } run(function*(){ let i = 0; while(i<10) { yield ++i, console.log(i); } }); // 1 2 3 4 5 6 7 8 9 10
在run(function*(/* ... */))中，先执行GeneratorFunction迭代对象返回Generator，然后用一个变量来存每次迭代结果...执行过程如下：
1. result={value:1,done:false}，打印 1；
2. 在step内，result={value:2,done:false}，打印 2；
3. 在step内，result={value:3,done:false}，打印 3；
...
10. 在step内，result={value:10,done:false}，打印 10；
11. 在step内，result={value:undefined,done:true}，迭代对象被完成。
如果yield后跟的是异步表达式呢？
代码如下：
// 基于上面的run函数 run(function*(){ const value1=yield fn1(); console.log('v1',value1); const value2 = yield fn2(); console.log('v2',value2) }) function fn1(){ const promise = new Promise(resolve => setTimeout(()=> resolve(' success'),3000)); promise.then(res=> console.log(res) ) return promise; }; function fn2(){ console.log('fn2'); return 'fn2'; } // v1 Promise // fn2 // v2 fn2 // 3s 后 success
假如需求需要fn2的执行依赖fn1的异步返回值，简单改造一下run执行器试试：
// 修改上面的run函数 function run(gen){ const iter = gen(); // result用来存储每一次迭代结果 let result = iter.next(); step(); function step(){ // 如果迭代对象未完成 if(!result.done){ // 如果是Promise，则在.then之后执行next if(result.value instanceof Promise){ result.value.then(res =>{ result = iter.next(res); step(); }) }else{ result = iter.next(result.value); step(); } } } }
以上是没看co代码之前针对问题"如果Generator对象迭代过程中某个迭代处理依赖上一个迭代结果该怎么办"想到的方法... 在实现方式上是差了些，但也可以用...
co实现的更好看且适用，每次迭代(function, promise, generator, array, object)都包装成Promise处理，针对不同场景/类型则关注toPromise层的判断。
对比一下ES7 async/await通过tsc --target es5 后的代码。
1. 首先是个__awaiter方法，里面是 new Promise；
2. 然后是个__generator方法，里面是GeneratorFunction。
也是用Promise包装Generator的模式实现... 把__awaiter摘出来后的代码：
var run = function (thisArg,_arguments,generator) { return new Promise(function (resolve, reject) { generator = generator.apply(thisArg, _arguments || []) function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } step(generator.next()); function step(result) { result.done ? resolve(result.value) : new Promise(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); } }); };
可能有些关联的文章：
文章仅供参考！！！关于更多Generator知识，以阅读文章开头官方文档为准，如更多的术语以及它们各代表什么过程...
学习过程中，多写几次总是会记得深刻些。
