1.简单知识点
执行 Generator 函数会返回一个遍历器对象
每次调用next方法，内部指针就从函数头部或上一次停下来的地方开始执行，直到遇到下一个yield表达式（或return语句）为止。换言之，Generator 函数是分段执行的，yield表达式是暂停执行的标记，而next方法可以恢复执行。
yield表达式只能用在 Generator 函数里面，用在其他地方都会报错。
yield表达式如果用在另一个表达式之中，必须放在圆括号里面。
-
对象的Symbol.iterator方法即是对象的便利生成器函数。Generator生成的遍历生成器对象也具有Symbol.iterator属性，这个属性返回他本身。
function* gen(){ // some code } var g = gen(); g[Symbol.iterator]() === g//true
2.next（）
-
yield表达式本身无返回值。next（）可以带一个参数，当作上一个yield的返回值。
e.g.function * fibonacci(){ let [prev, curr] = [0, 1]; for(;;){ [prev, curr] = [curr, curr+prev]; yield curr; } } for(let n of fibonacci()){ if(n>1000){ break; } console.log(n); }
补充：for..of，解构赋值，Array.from(），...扩展运算符调用的都是遍历器接口。
3.throw（）
throw抛出的错误，由try-catch语句中的catch捕获。throw 分为外部的throw命令和生成器的throw（）方法。throw命令抛出的错误只能被函数体外捕获。
-
函数体外抛出异常，函数能够捕获。
try{ g.throw("error"); }catch(e){ console.log(e); }
一旦 Generator 执行过程中抛出错误，且没有被内部捕获，就不会再执行下去了。如果此后还调用next方法，将返回一个value属性等于undefined、done属性等于true的对象，即 JavaScript 引擎认为这个 Generator 已经运行结束了。
同样函数内部抛出的错误，函数外部可以捕获。函数内部有try-catch语句块，g.throw（）先被函数内部的try-catch捕获。当函数内部不存在try-catch语句块时，直接被函数外部的try-catch捕获。捕获到函数内部抛出的错误错误，则g.next().done为true，表示遍历结束，不再执行。
- throw方法被捕获后，会附带执行下一条yield表达式。
- throw命令与g.throw()无关。两者不影响。throw命令不会影响遍历器的状态。
4.return（）
g.return('foo');
调用return（）结束遍历器，并返回遍历器的返回值。
注意try-finally语句块。调用return（）后，执行finally块中的代码，执行完后返回return（）。
总结：return（），next（），throw（），都是对yield表达式的替换。next是值的替换，throw（）替换成throw语句，return（）替换成return语句
5.关于yield
在generator函数中调用generator。利用yield*
yield * iterator对象 相当于for...of遍历的简写-
利用yield创建二叉树
function Tree(left, label, right) { this.left = left; this.label = label; this.right = right; } function make(array) { // 判断是否为叶节点 if (array.length == 1) return new Tree(null, array[0], null); return new Tree(make(array[0]), array[1], make(array[2])); } let tree = make([[['a'], 'b', ['c']], 'd', [['e'], 'f', ['g']]]); console.log(tree); 利用yield遍历二叉树
6.generator中的this
generator不能够和new一起用，所以就不能够将this绑定在生成器
出现的问题是：
function* g() {
this.a = 11;
}
let obj = g();
obj.a // undefined
解决方法，创建空对象，使用call绑定generator内部的this对象
function* F() {
this.a = 1;
yield this.b = 2;
yield this.c = 3;
}
var obj = {};
var f = F.call(obj);
f.next(); // Object {value: 2, done: false}
f.next(); // Object {value: 3, done: false}
f.next(); // Object {value: undefined, done: true}
obj.a // 1
obj.b // 2
obj.c // 3
7.generator函数与状态机
generator中一个yield就是一个状态
*8.generator与协程序
- 协程就是：一个线程（或函数）执行到一半，可以暂停执行，将执行权交给另一个线程（或函数），等到稍后收回执行权的时候，再恢复执行。这种可以并行执行、交换执行权的线程（或函数），就称为协程。
- 协程与普通线程的区别：同一时间可以有多个线程处于运行状态，但是运行的协程只能有一个，其他协程都处于暂停状态。此外，普通的线程是抢先式的，到底哪个线程优先得到资源，必须由运行环境决定，但是协程是合作式的，执行权由协程自己分配。
9.generator的应用
异步同步化
利用yield，按顺序执行异步函数
多步骤管理
-
promise的方式
Promise.resolve(step1) .then(step2) .then(step3) .then(step4) .then(function (value4) { // Do something with value4 }, function (error) { // Handle any error from step1 through step4 }) .done();
promise.done：不会反悔promise对象，因此不能够接cache（），形成promise链。异常直接抛出给外部。作用，防止promise中的人为的，难以查找出的错误。
-
generator 中yield
function* longRunningTask(value1) { try { var value2 = yield step1(value1); var value3 = yield step2(value2); var value4 = yield step3(value3); var value5 = yield step4(value4); // Do something with value4 } catch (e) { // Handle any error from step1 through step4 } }
注意：这里generator是同步化的，不存在异步调用。
部署iterator 接口
function* iterEntries(obj) {
let keys = Object.keys(obj);
for (let i=0; i < keys.length; i++) {
let key = keys[i];
yield [key, obj[key]];
}
}
let myObj = { foo: 3, bar: 7 };
for (let [key, value] of iterEntries(myObj)) {
console.log(key, value);
}
// foo 3
// bar 7
Object.keys()
Object.keys() 方法会返回一个由一个给定对象的自身可枚举属性组成的数组，数组中属性名的排列顺序和使用 for...in循环遍历该对象时返回的顺序一致 （两者的主要区别是 一个 for-in 循环还会枚举其原型链上的属性）
作为数据结构
