generator函数

Generator函数是ES6提供的一种异步编程解决方案

Generator暂停时，之后语句可以正常执行

之前异步编程的方法大概有四种

 1.回调函数

 2.事件监听

 3.发布/订阅

 4.Promise对象

从语法上理解，Generator函数是一个状态机，封装了多个内部状态，执行Generator函数会返回一个遍历器对象，也就是说Generator函数除了状态机还是一个遍历器对象生成函数。返回的遍历器对象，可以一次遍历Generator函数内部的每一个状态。

就像是在数组中取值，如果数组中有5个值，第一次只取一个值，则取值这个操作暂停，但是取值之后的主线程不会停止。

Generator函数是协程在ES6的实现，最大特点就是可以交出函数的执行权(即暂停执行)

整个Generator函数就是一个封装的异步任务，或者说是异步任务的容器。异步操作需要暂停的地方都用yield语句著名

function* helloWorldGenerator(){
    yield 'hello';
    yield 'world';
    return 'ending';
}
var hw=helloWorldGenerator();
console.log(hw.next());//{ value: 'hello', done: false }
console.log(hw.next());//{ value: 'world', done: false }
console.log(hw.next());//{ value: 'ending', done: true }
console.log(hw.next());//{ value: undefined, done: true }

定义Generator函数时使用function*  使用yield语句定义内部状态。以上代码有两个yield函数即有三个状态

调用函数后并不会执行，返回的是只想内部状态的指针对象也就是遍历器对象。

必须调用遍历器对象的next方法，使得指针移向下一个状态。每次调用next方法内部指针就从函数头部或上一次停下来的地方开始执行，知道遇到下一个yield语句（或return语句）为止。也就是说Generator函数是分段进行的，yield语句是暂停执行的标记，而next方法可以恢复执行
总结一下：调用Generator函数，返回一个遍历器对象，代表Generator函数的内部指针。以后每次调用遍历对象的next方法，就会返回一个有着value和done两个属性的对象。value属性表示当前的内部状态的值，是yield语句后面那个表达式的值；done属性是一个布尔值，表示是否遍历结束

yield语句

yield语句和return 语句相似处：返回紧跟在语句后面的那个表达式的值。区别处：遇到yield语句函数暂停，下次从该位置执行，而return 语句不具备记忆功能，且return 语句只能运行一次。

在普通函数中添加yield语句会报错

在Generator函数总可以不使用yield，那么该Generator就变为了一个单纯的暂缓执行函数

function* f(){
    console.log('执行');
}
var generator=f();
setTimeout(function(){
    generator.next();
},2000)

next方法的参数

yield语句本身没有返回值，总是返回undefined。next方法可以带一个函数，该函数会被当作上一个yield语句的返回值，第一个next方法带参数无效，方法是用来启动遍历器对象。

function* helloWorldGenerator(){
    var step1= yield 'hello';
    console.log(step1);//step1
    var step2= yield 'world';
    console.log(step2);//undefined
    return 'ending';

}
var hw=helloWorldGenerator();
console.log(hw.next());//{ value: 'hello', done: false }
console.log(hw.next('step1'));//{ value: 'world', done: false }
console.log(hw.next());//{ value: 'ending', done: true }
console.log(hw.next());//{ value: undefined, done: true }

Generator函数从暂停状态到恢复运行，它的上下文状态（context）是不变的。通过next方法的参数，在Generator函数开始运行之后，继续向函数内部注入值。可以在Generator函数运行的不同阶段，从外部想内部注入不同的值，从而调整函数行为。

for...of循环

for...of循环可以自动遍历Generator函数，且不再需要调用next方法

function* foo(){
    yield 1;
    yield 2;
    yield 3;
    yield 4;
    yield 5;
    return 6;
}
for(var v of foo()){
    console.log(v);
}
//1 2 3 4 5

使用for...of循环，此次显示了5个yield语句的值。一旦next方法的返回对象的done属性为true，循环就会终止，且不包含该返回对象，及不包含代码中return语句返回值

Generator.prototype.throw()

Generator函数返回的遍历器对象，都有一个throw方法，可以在函数体外抛出错误，然后再Generator函数体内捕获

var  g=function* (){
    while(true){
        try{
            console.log('运行');
            yield 1;
        }catch(e){
            if(e != 'a') throw  e;
            console.log('内部捕获',e);
        }
    }
};
var i= g();
i.next();
console.log('异常测试');
try{
    i.throw('a');
    i.throw('b');
    i.throw('c');
}catch(e){
    console.log('外部捕获',e);
}
//运行
//异常测试
//内部捕获 a
//运行
//外部捕获 b

如果Generator函数内部部署了try...catch代码块，那么遍历器的throw方法抛出的错误，不影响下一次遍历，否则遍历直接终止

function* g(){
    try {
        var a = yield foo('a');
        var b = yield foo('b');
        var c = yield foo('c');
    } catch (e) {
        console.log(e);
    }

    console.log(a, b, c);
}

函数异常判断

yield* 语句

yield* 语句表明它返回的是一个遍历器对象

function* foo(){
    yield 2;
    yield  3;
    yield  4;
    return "foo";
}
function* bar(){
    yield 1;
    yield *foo();
    yield 5;
}
var it=bar();
console.log(it.next());//{ value: 1, done: false }
console.log(it.next());//{ value: 2, done: false }
console.log(it.next());//{ value: 3, done: false }
console.log(it.next());//{ value: 4, done: false }
console.log(it.next());//{ value: 5, done: false }
console.log(it.next());//{ value: undefined, done: true }