ES6之Generator函数(4)知识点总结(十一)

版权声明: https://blog.csdn.net/lhjuejiang/article/details/79955724

Generator函数的数据交换和错误处理。

Generator函数可以暂停执行和恢复执行,这是它能封装异步任务的根本原因。除此之外,它还有两个特性,使他可以作为异步编程的完整解决方案:函数体内的数据交换和错误处理机制。next返回值的value属性,是Generator函数向外输出数据,next方法还可以接受参数,向Generator函数体内输入数

function *g(x){
    yield "leo";
  var y=  yield  "lalalal"+x;
    return y;

}
var p = g(1);
console.log(p.next());// { value: "leo", done: false }
console.log(p.next('donna'));//{ value: "lalalal1", done: false }
console.log(p.next("honery"));//{ value: "honery", done: true }
console.log(p.next("honery"));// { value: undefined, done: true }

Generator函数内部还可以部署错误处理代码,捕获函数体外抛出的错误

    try {
        var y = yield x + 2;
    } catch (e){
        console.log(e);
    }
    return y;
}

var g = gen(1);
console.log(g.next());//{ value: 3, done: false }
g.throw('出错了');
console.log(g.next(12));//{ value: undefined, done: true }

上面的代码,在Generator函数体外,使用指针对象的throw方法抛出的错误,可以被函数体内的try…catch代码块捕获。这意味着,出错的代码与处理错误的代码,在时间和空间上的分离。

再看一个例子

function* gen(x){
    try {
        var y = yield x + 2;
    } catch (e){
        console.log(e);
    }
    yield "donna";
    return y;
}

var g = gen(1);
console.log(g.next());//{ value: 3, done: false }
console.log(g.throw('出错了'));//{ value: "donna", done: false }
console.log(g.next(12));//{ value: undefined, done: true }

我们之前说过,go.throw方法被捕获以后,自动执行了一次next方法,但从上面的两个例子中我们可以发现,go.throw方法只会自动执行yield语句,但并不自动执行return语句,这和调用next方法还是有区别的。当然,只要Generator函数内部部署了try…catch代码块,那么遍历器的throw方法抛出的错误,不影响下一次遍历,这也是从上面的代码中可以看到的。


之前忽略了next方法参数的作用,今天给补上

next方法的参数:

yield表达式本身没有返回值,或者说总是返回undefined。next方法可以带一个参数,该参数就会被当做上一个yield表达式的返回值。

注意,由于next方法的参数表示上一个yield表达式的返回值,所以,在第一次调用next方法时,传递的参数是无效的,只有第二次调用next方法,传递的参数才是有效的。从语法上讲,第一个next方法用于启动遍历器对象,所以不用带参数。

看个例子

function *g(x){
    yield 2+x;
  var y=  2*(yield  3+x);
  yield y;
    return y+x;

}
var p = g(1);
console.log(p.next());// { value: 3, done: false }
console.log(p.next(7));// { value: 4, done: false }
console.log(p.next(5));// { value: 10, done: false }
console.log(p.next(5));// { value: 11, done: false }
console.log(p.next(6));// { value: undefined, done: false }
切记:next方法返回的是yield表达式后面的值,next方法传递的参数不是x的值,而是上一个yield表达式的返回值(不是上一个整个表达式的值,知识yield后面的值)。所以上面的代码,第一次调用next方法时,返回的是2+x,x=1,所以就是3,第二次调用next方法,虽然传递了参数,但它代表的上一个yield表达式的值,而我们并没有使用这个值,第三次调用next方法的时候,传递的参数为4,说明上一个yield表达式3+x=5,所以y = 2*5=10,所以这一次yield的值为10,第四次调用next方法,由于y=10,x=1,所以返回的结果就是11.
function *g(x){
    yield 2+x;
  var y=  2*(yield  3+x);
  yield y+1;
    yield y+x;

}
var p = g(1);
console.log(p.next());// { value: 3, done: false }
console.log(p.next(7));// { value: 4, done: false }
console.log(p.next(5));// { value: 11, done: false }
console.log(p.next(5));// { value: 11, done: false }此处y=10,x=1
console.log(p.next(6));// { value: undefined, done: false }
    function *g(x){
        yield 2+x;
        var y=  2*(yield  3+x);
       var z =  yield y+1;
        yield z+x+y;

    }
    var p = g(1);
    console.log(p.next());// { value: 3, done: false }
    console.log(p.next(7));// { value: 4, done: false }
    console.log(p.next(5));// { value: 11, done: false }
    console.log(p.next(5));// { value: 16, done: false }此处z=5,y=10,x=1
    console.log(p.next(6));// { value: undefined, done: false }

还有下面的情况

    function *g(x){
        yield 2+x;
        var y=  2*(yield  3+x);
       var z =  yield 1;
        yield z+x+y;

    }
    var p = g(1);
    console.log(p.next());// { value: 3, done: false }
    console.log(p.next(7));// { value: 4, done: false }
    console.log(p.next(5));// { value: 1, done: false }
    console.log(p.next(5));// { value: 16, done: false }
    console.log(p.next(6));// { value: undefined, done: false }
    function *g(x){
        yield 2+x;
        var y=  2*(yield  3+x);
       var z =  yield 1;
        yield z+x+y;

    }
    var p = g(1);
    console.log(p.next());// { value: 3, done: false }
    console.log(p.next(7));// { value: 4, done: false }
    console.log(p.next());// { value: 1, done: false }
    console.log(p.next(5));// { value: NaN, done: false }
    console.log(p.next(6));// { value: undefined, done: false }

做一个小小的总结:next方法返回一个对象,它的value属性就是当前yield表达式的值(此处暂且不讨论done属性的值),如果next方法在调用的时候传递了参数(不包括第一个调用next方法),那么这个参数就是上一个yield表达式的返回值,也可以说就是当上一个yield表达式整体(或yield整体运算后)赋值给了一个变量,而下一次调用next方法,上一个yield表达式的值就是本次next方法的参数,如果没有传参,则为undefined。(还有就是不要和next参数和Generator参数搞混喽)

这几个对比,每一个改动都很小,把我的疑惑的疑惑解决了,我自己总结了一下,可能有些说法不太科学,仅供参考(当然如果哪里说法不对,也希望您可以提出您的宝贵意见),实践才是检验真理的唯一标准,嗯、还是要多动手才是。


阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页