Generator函数是协程在ES6的实现，最大的特点就是可以交出函数的执行权（即暂停执行）。
Generator函数和普通函数区别有两个，
1：function和函数名之间有一个*号，
2：函数体内部使用了yield表达式；比如这样：
function *gen(){
yield '1';
yield '2';
return '3';
}
整个Generator函数就是一个封装的异步任务，或者说是异步任务的容器。异步操作需要暂停的地方，都用yield语句注明。Generator函数的执行方法如下。
var g = gen();
g.next(); //{value: 1 ,done:fasle}
g.next(); //{value: 2 ,done:fasle}
g.next(); //{value: 3 ,done:true}
上面的代码中，调用Generator函数，会返回一个内部指针（即遍历器）g。这是Generator函数不同于普通函数的另一个地方，即执行它不会返回结果，返回的是指针对象。调用指针g的next（）方法，会移动指针，指向第一个遇到的yield语句。并且将yield的参数返回给next这个方法的value。再次调用就会执行第二个yield语句，返回它的参数。
可以看到next方法返回2个参数，一个是value，一个是done，第一个value就是yield的参数，第二个就是表示遍历是否结束。以上代码它让retrun了，所以代码结束，返回true。
yield配合字符串输出的话必须要加一个（），比如
function *gen(){
console.log('hello'+(yield));
console.log('hello'+(yield 123));
}
next方法可以进行传参
yield表达式本身没有返回值，或者说总是返回undefined。next方法可以带一个参数，该参数就会别当成yield的返回值。比如
function* gen(x){
var y = 2 * (yield(x+ 1));
var z = yield (y/3);
return (x+y+z);
}
var a = gen(5);
a.next() // value: 6;
a.next() // value:NaN;
a.next() // value:NaN;
var b = gen(5);
b.next(); // value:6;
b.next(12); //value :8
b.next(13);//value:42
上面代码中，第二次运行next方法的时候不带参数导致y返回undefined，2undefined，所以返回NaN，后一个同理。
如果在next中传入参数，第一个x+1 = 6；返回6，第二个next传参12，212 = 24；24/3 = 8；返回8，第三个next传参13, 5 + 24 + 13 = 42。返回42。
Generator可以通过for...of遍历，遍历不再需要next方法。
function *gen(){
yield 1;
yield 2;
yield 3;
yield 4;
yield 5;
return 6;
}
for(let v of gen()){
console.log(v);//1 2 3 4 5
}
上面代码使用for...of循环，依次显示5个yield表达式的值，这里需要注意一下，一旦next方法的返回对象的done属性为true，for...of循环就会中止。且不包含该返回对象，所以上面代码retrun 6，不包括在for...of循环之中。
除了for...of循环之外，扩展运算符（...）、解构赋值和array.from方法内部调用的，都是遍历器接口。这意味着，它们都可以将Generator函数返回的Iterator对象，作为参数。
function *gen(){
yield 1;
yield 2;
return 3;
yield 4;
}
// 扩展运算符
[...gen()] // [1，2]
// Array.from 方法
Array.from(gen()); // [1，2]
// 解构赋值
let [x,y] = gen();
x // 1
y // 2
// for...of 循环
for(let v of gen()){
console.log(n);
// 1
// 2
}
Generator函数返回的遍历器对象，都有一个throw方法，可以在函数体外抛出错误，然后在Generator函数体内捕获。
var g = funciton* (){
try{
yield;
} catch(e){
console.log('内部捕获'，e)
}
}
var i = g();
i.next();
try{
i.throw('a');
i.throw('b');
} catch(e){
console.log('外部捕获'，e)；
}
// 内部捕获 a
// 外部捕获 b
上面代码中，遍历器对象i连续抛出两个错误。第一个错误被Generator函数体内的catch语句捕获。i第二次抛出错误，由于Generator函数内部的catch语句已经执行过啦，不会再捕获这个错误啦，所以这个错误就被抛出了Generator函数体，被函数体外的catch语句捕获。
Generator函数返回的遍历器对象，还有一个return的方法，可以返回给定的值，并且终结遍历Generator函数。
funciton *gen(){
yield 1;
yield 2;
yield 3;
}
var g = gen();
g.next(); // value 1 done :false
g.return('foo') // value 2 done :false
g.next() // value :undefined done :true
上面的代码中，遍历器对象g调用retrun方法后，返回值的value属性就是retrun方法的参数foo。并且Generator函数的遍历就终止了，返回值的done属性为true，以后再调用next方法，done属性总是返回true。 如果retrun没有传参，那么返回的value就是undefined。
如果Generator函数内部有try...finally代码块，那么retrun方法会推迟到finally代码块执行完在执行。
funciton* gen(){
yield 1;
try{
yield 2;
yield 3;
} finally{
yield 4;
yield 5;
}
yield 6;
}
var g = gen();
g.next(); // value :1 done :false
g.next(); // value :2 done :false
g.reture(7); // value :4 done :false
g.next(); // value :5 done :false
g.next(); // value :7 done :true
上面代码中，调用retrun方法后，就开始执行finally代码块，然后等到finally代码块执行完，在执行retrun方法。
yield* 表达式
假如foo和bar都是Generator函数，在bar里面调用foo，是不会有效果的。
这个就需要用到yield*表达式，用来在一个Generator函数里面执行另一个Generator函数
funciton* bar(){
yield 'x';
yield* foo();
yield 'y';
}
//等同于
funciton* bar(){
yield 'x';
yield 'a';
yield 'b';
yield 'y';
}
//等同于
function* bar(){
yield 'x';
for(let v of foo()){
yield v;
}
yield 'y';
}
for(let v of bar()){
console.log(v);
}
// 'x'
// 'a'
// 'b'
// 'y'
yield* 后面的Generator函数（没有retrun语句时），等同于在Generator函数内部，部署一个for...of循环。
function *concat(item1,item2){
yield* item1;
yield* item2;
}
// 等同于
function* concat(item1，item2){
for(var value of item1){
yield value;
}
for(var value of item2){
yield value;
}
}
如果yield*后面跟着一个数组，由于数组原生支持遍历器，因此就会遍历数组成员。
function* gen(){
yield* [1,1,1,2,3,3,5];
}
gen().next() // value 1;
上面代码中，yield命令后面如果不加星号，返回的是整个数组，加了星号之后返回的就是数组遍历的对象。
