Generator函数（二）

for...of循环

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

function* helloWorldGenerator(){

    yield 'hello';

    yield 'world';

    return 'ending';

}

for (let f of helloWorldGenerator()){

    console.log(f);//'hello','world'

}

var hw = helloWorldGenerator();

hw.next();

hw.next();//done的值是false

hw.next();//done的值是true，所以此时不会再输出ending

这里使用for...of循环和next()方法遍历Generator函数，在使用for...of循环可以自动遍历Generator函数，且此时不再需要调用next方法。

而且遍历出来的结果也不同。

2.前面章节介绍过，for...of循环，扩展运算符（...）,解构赋值和array.from方法内部调用的都是遍历器接口。这就是说，他们可以将Generator函数返回的Iterator对象作为参数。

function* numbers(){

    yield 1;

    yield 2;

    return 3;

    yield 4;

}

[...numbers()];//[1,2],扩展运算符（...）

Array.from(numbers()) //[1,2],Array.from方法

let [x,y] = numbers(); //解构赋值

x//1

y//2

for(let n of numbers()){

    console.log(n);

}

//1

//2

3.使用Generator函数和for...of循环为原生的JavaScript对象加上遍历接口

function* objectEntries(obj){

    let propKeys = Reflect.ownKeys(obj);//获取一个对象obj的key

    for(let propKey of propKeys){

        yield [propKey,obj[propKey]];

    }

}

let jane = {first:'jane',last:'Doe'};

for(let [key,value] of objectEntries(jane)){

    console.log(`${key}:${value]`);

}

// first:jane

// last:Doe

第二种方法实现添加遍历接口

    function* objectEntries(obj){

        let propKeys = Reflect.ownKeys(obj);

        for(let propkey of propKeys){

            yield [propkey,obj[propkey]];

        }

    }

    let jane = {first:'jane',last:'doe'};

    jane[System.iterator] = objectEntries;

    for(let [key,value] of jane){

        console.log(`${key}:${value}`);

    }

    //  first:jane

    //  last:doe

Generator.prototype.throw()

1.Generator函数返回的遍历器都有一个throw方法，可以在函数体外抛出错误，在函数体内捕获错误。

var g = function* (){

    while (true ){

        try{

            yield;

        }catch (e){

            if(e != 'a') throw e;

            console.log('内部捕获',e);

        }

    }

};

var i = g();

i.next();

try{

    i.throw('a');

    i.throw('b');

}catch(e){

    console.log('外部捕获',e);

}

//内部捕获 a

//外部捕获 b

总结一下，有几种错误抛出和捕获的情况。

（1）Generator函数体内有try...catch块，函数体外也有try...catch块，如果函数体外用多个throw方法抛出错误：

解决错误的情况：第一个throw方法，将被函数体内的捕获，后面的throw方法会被函数体外的捕获。(因为Generator函数内部的catch语句已经执行过了，不会再捕获到后面的throw方法抛出的错误)

（2）Generator函数体内和体外都有try...catch块，如果函数体外用throw命令抛出错误：

解决情况：因为用throw命令抛出的错误，只能被函数体外的catch捕获，即使函数体内有catch块。

（3）Generator函数体内没有try...catch块，函数体外有try...catch块，如果函数体外用throw方法或者throw命令抛出错误：

解决情况：被外部的try...catch块捕获。

（4）Generator函数体内和体外都没有try...catch块，那么如果抛出错误：程序会报错，直接中断执行。

2.关于Generator函数体内有无try...catch块，会不会影响到遍历器的状态，即关系到next方法会不会被正常执行。

如果Generator函数体内没有try...catch块，则遍历器的throw方法抛出的错误不会影响到下一次的遍历，否则遍历直接终止，但是如果用的是throw命令，则不会影响到遍历器的状态。

var gen = function* gen(){

    yield console.log('hello');

    yield console.log('world');

}

var g = gen();

g.next();

try {

    g.throw();

}catch(e){

    g.next();

}

//hello

虽然Generator函数内部没有部署try...catch块，那么throw方法抛出的错误即使会被外部的try...catch代码块捕获。

但是第二次调用next()方法的时候遍历器状态已经变成终止了。但是使用throw命令（throw new Error()）抛出的错误就不会影响到遍历器的状态，即next()方法。

3.Generator函数这种函数体内捕获错误的机制大大方便了对错误的处理。如果使用回调函数，想要捕获多个错误的话，就不得不为每个函数写一个错误处理语句。

但是使用Generator函数就会简化很多，例如

    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);

    }

4.Generator函数体内抛出的错误也可以被函数体外的catch捕获。

    function* foo(){

        var x = yield 3;

        var y = x.toUpperCase();//这里报错

        yield y;

    }

    var it = foo();

     it.next();

    try{

        it.next(42);

    }catch(err){

        console.log(err);//这里捕获

    }

巴特西

Generator函数（二）

for...of循环

Generator.prototype.throw()

最新文章

热门文章