Generator函数（三）

Generator.prototype.return()

1.Generator函数返回的遍历器对象还有一个return方法，可以返回给定的值，并终结Generator函数的遍历。

    function* gen(){
        yield 1;
        yield 2;
        yield 3;
    }
    var g = gen();
    g.next();// {value:1,done:false}
    g.return("foo");//{value:foo,done:false}
    g.next();//{value:undefined,done:false}
    //上面的代码中，遍历器对象g调用return方法之后，返回的也是一个对象，而且这个对象的value属性就是return方法的参数foo.同时,Generator函数的遍历终止，返回值的done属性为true，以后再调用next方法，done属性总是返回true。如果return方法调用时不提供参数，则返回值的value属性为undefined。

2.如果Generator函数内部有try...finally代码块，那么return方法会推迟到finally代码块执行完再执行。

function* numbers(){
       yield 1;
       try{
            yield 2;
            yield 3;
        }finally{
            yield 4;
            yield 5;
        }
        yield 6;
}
var g = numbers();
g.next(); //value:1
g.next();//value:2
g.return(7);//value:4
g.next();//value:5
g.next();//value:7

yield*语句

如果在Generator函数内部调用另一个Generator函数，默认情况下是没有效果的，必须要使用yield*语句
1.这个语句的作用：主要是用来在一个Generator函数中使用另一个Generator函数。

    function* foo(){
        yield 'a';
        yield 'b';
    }
    function* bar(){
        yield 'x';
        foo();  // 将这里修改成yield* foo(),就会有效果
        yield 'y';
    }
    for(let v of bar()){
        console.log(v);
    }
    //"x"
    //"y"在这里面直接用yield语句是没有任何效果的

2.从语法角度看，如果yield命令后面跟的是一个遍历器对象，那么需要在yield命令后面加上星号，表明返回的是一个遍历器对象。这被称为yield*语句。

    let delegatedIterator = (function* (){
        yield 'hello!';
        yield 'bye!';
    }());

    let delegatingIterator = (function* (){
        yield 'Greetings!';
        yield* delegatedIterator;
        yield 'ok,bye.';
    }())

    for(let value of delegatingIterator){
        console.log(value);
    }

    //"Greeting"
    //"hello"
    //"bye!"
    //"ok,bye"

总结下来：（1）运行结果，就是使用一个遍历器遍历了多个Generator函数，有递归的效果。
（2）yield* 语句等同于在Generator函数内部部署一个for...of循环。
（3）yield* 语句后面还可以接数组，因为数组原生支持遍历器，因此会遍历数组成员
（4）yield* 语句后面，只要是有Iterator接口，都可以用yield*遍历。

3.如果被代理的Generator函数有return语句，那么可以向代理它的Generator函数返回数据。

    function* foo(){
        yield 2;
        yield 3
        return "foo";
    };
    function* bar(){
        yield 1;
        var v = yield* foo();
        console.log("v:" + v);
        yield 4;
    }
    var it = bar();
    it.next();//value:1
    it.next();//value:2
    it.next();//value:3
    it.next();//"v:foo",value:4这里不是太明白，姑且认为是因为foo函数被bar()函数代理的缘故

4.yield*语句的一些比较常用的例子
（1）可以很方便的取出嵌套数组的所有成员

    function* iterTree(tree){
        if(Array.isArray(tree)){ //判断是否是一个嵌套在数组内部的数组
            for(let i=0;i<tree.length;i++){
                yield* iterTree(tree[i]);//采用循环和递归的方法，来遍历出数组中的嵌套数组的成员
            }
        }else{
             yield tree;
        }
    }

    const tree = ['a',['b','c'],['d','e']];
    for(let x of iterTree(tree)){
        console.log(x);
    }
    //a
    //b
    //c
    //d
    //e

（2）yield* 语句可以用来遍历完全二叉树

    //用构造函数构造一个完全二叉树
    //3个参数分别是左子树，当前节点，右子树。
    function Tree(left,label,right){
        this.left = left;
        this.label = label;
        this.right = right;
    }
    
    //下面是中序（inorder）遍历函数
    //由于返回的是一个遍历器，所以要用Generator函数。
    //函数体内采用递归算法，所以左子树和右子树要用yield*遍历。
    function* inorder(t){
        if(t){
            yield* inorder(t.left);
            yield  t.label;
            yield* inorder(t.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']]]);
    //var result = [];
    for(let node of inorder(tree)){
        //result.push(node);
        console.log(node);
    }

作为对象属性的Generator函数

1.如果一个对象的属性是一个Generator函数，则可以这样写：

    let obj = {
        * myGeneratorMethod(){
            ...
        }
    }
    //也可以这样写：
    let obj = {
        myGeneratorMethod:function* (){}
    };

Generator函数的this

1.Generator函数总是返回一个遍历器，ES6规定这个遍历器是Generator函数的实例，它也继承了Generator函数的prototype对象上的方法。
2.如果只是把Generator函数当作普通的构造函数，并不会有任何效果，因为Generator函数返回的始终是遍历器对象，而不是this对象

function* g(){
    this.a = 11;
}
let obj = g();
obj.a //undefined

3.还有如果使用new命令，这是不能生成F的实例，因为F返回的是一个内部指针。

function* F(){
    yield this.x = 2;
    yield this.y = 3;
}

上面的方法是没有任何效果的，想要把Generator函数当作正常的构造函数来使用，可以采用下面的变通方法。

    function* F(){
        yield this.x = 2;
        yield this.y = 3;
    }
    var obj = {};
    var f = F.bind(obj)();//将obj和this绑定在一起。
    //再次调用next方法
    f.next();
    f.next();
    f.next();
    obj //{x:2,y:3}

Generator函数推导

1.利用函数推导，可以进行惰性求值，如果需要将一个数组中的每个成员进行平方，如果用到函数推导，那么就只会在用到的时候，才会占用系统资源。
否则会先定义一个数组，这时候系统会被占用很大一部分资源。

    let generator = function* () {
        for(let i=0;i<6;i++){
            yield i;
        }
    }
    let squared = ( for (n of generator()) n*n);
    //等同于
    //let squared = Array.from(generator()).map( n => n*n);
    console.log(...squared);
    //0 1 4 9 16 25

Generator函数推导是对数组结构的一种模拟，其最大的优点就是惰性求值，即直到真正用到的时候才会求值，这样可以保证效率。

含义

1.Generator与状态机
Generator函数很好的实现了两个或者两个状态以上的切换过程，而且是合作式的。

    var clock = function*(_){
        while(true){
            yield _;
            console.log('Tick');
            yield _;
            console.log('Tock');
        }
    }  

2.Generator与协程
传统的“子例程”采用堆栈式“后进先出”的执行方式，只有当调用的子函数完全执行完毕，才会结束执行父函数。协程与其不同，多个线程（单线程情况下即多个函数）可以并行执行，但只有一个线程（或函数）处于正在运行的状态，其他线程（或函数）都处于暂停态，线程（或函数）之间可以交换执行权。也就是说，一个线程（或函数）执行到一半，可以暂停执行，将执行权交给另一个线程（或函数），等到稍后收回执行权时再恢复执行。这种可以并行执行、交换执行权的线程（或函数），就称为协程。
从实现上看，在内存中子例程只使用一个栈，而协程是同时存在多个栈，但只有一个栈是在运行态。也就是说，协程是以多占用内存为代价实现多任务的并行运行。
3.协程与普通线程的差异
普通的线程是抢占式的，到底哪个线程优先得到资源，必须由运行环境决定，但是协程是合作式的，执行权由协程自己分配。而且Generator函数是ES6对协程的实现，但属于不完全实现。如果将Generator函数当作协程，完全可以将多个需要协作的任务写成Generator函数，他们之间用yield语句交换控制权。

Generator函数的主要应用

1.异步操作的同步化表达
例如：ajax操作，

function* main(){
	var result = yield request("http:fff.url");//这里通过调用next方法来传递给result
	var resp = JSON.parse(result);
	console.log(resp.value);
}

function request(url){
	makeAjaxCall(url,function(response){
		it.next(response);//将这个response传递给result,这里必须在next方法加上response参数，因为yield语句构成的表达式本身是没有值的，总是等于undefined。
	})//这个函数主要是用来获取应答数据
}
var it = main();
it.next();

2.控制流管理：同步运行和异步运行
3.部署Iterator接口：利用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];//这里通过yield
	}
}
let myObj = {foo:3,bar:7};
for(let [key,value] of iterEntries(myObj)){
	console.log(key,value);//这里用for...of循环来遍历Generator函数
}

最后注意：
1.yield 语句后面可以接普通函数，也可以正常执行。
2.yield* 语句主要是用来在一个Generator函数中执行另一个Generator函数。主要可以实现递归。