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 循环还会枚举其原型链上的属性）
作为数据结构