深入探讨ES6生成器

如果对于ES6生成器不熟悉，请先阅读并运行下http://www.cnblogs.com/linda586586/p/4282359.html里面的代码。当你感觉掌握了基础之后，我们可以深入探讨一些细节。

错误处理

在ES6生成器设计中最强大的是一个生成器内部代码的语义是同步的，即使外部迭代控制是异步的。

可以使用简单的也许你很熟悉的错误处理技术--就是try-catch机制。

例如：

function *foo() {
    try {
        var x = yield 3;
        console.log( "x: " + x ); // may never get here!
    }
    catch (err) {
        console.log( "Error: " + err );
    }
}

即使函数会在yield3处暂停，也许会保持暂停状态任意一段时间，如果回传给生成器错误，try-catch会捕获它！试着使用普通异步方法处理，像回调函数。

但是，错误回传给这个生成器有多精确？

var it = foo();

var res = it.next(); // { value:3, done:false }

// instead of resuming normally with another `next(..)` call,
// let's throw a wrench (an error) into the gears:
it.throw( "Oops!" ); // Error: Oops!

可以看到，在迭代器中用到的另外一个方法--throw(),会向生成器抛错，就好像正好发生在生成器yield暂停位置的点上。try-catch语句就像所期望的那样捕获了错误！

注：如果向生成器内抛错，但是没有try-catch捕获它，错误会传播回去。所以：

function *foo() { }

var it = foo();
try {
    it.throw( "Oops!" );
}
catch (err) {
    console.log( "Error: " + err ); // Error: Oops!
}

显然，反方向的错误处理也起作用了：

function *foo() {
    var x = yield 3;
    var y = x.toUpperCase(); // could be a TypeError error!
    yield y;
}

var it = foo();

it.next(); // { value:3, done:false }

try {
    it.next( 42 ); // `42` won't have `toUpperCase()`
}
catch (err) {
    console.log( err ); // TypeError (from `toUpperCase()` call)
}

代理生成器

另外想要做的是从生成器函数内部调用另外一个生成器。这意思不仅仅是用普通的方法实例化生成器，实际上是对于其他生成器代理迭代控制。为了这样做，可以使用yield关键字的一个变形：yield *("yield star").例子：

function *foo() {
    yield 3;
    yield 4;
}

function *bar() {
    yield 1;
    yield 2;
    yield *foo(); // `yield *` delegates iteration control to `foo()`
    yield 5;
}

for (var v of bar()) {
    console.log( v );
}
// 1 2 3 4 5

就像前面一篇介绍的，这里也使用yield *foo()代替了其他文章里面的yield* foo()。我认为它可以更确切的说明在发生的事情。
    让我们看看这个是怎么工作的。yield 1和yield 2直接把他们的值送出到了for of循环的next()调用，像我们所了解和期望的那样。

但是yield*被碰到了，你会注意到我们正通过实例化foo()进入另外一个生成器.所以我们在为另外一个生成器迭代进行代理。

当yield*从*bar()到*foo()代理时，for-of循环的next()调用是控制foo(),然而yield 3和yield4将他们的值送出去到for-of循环。

当*foo()结束的时候，控制返回到原始的生成器中，最后调用yield 5。

简化下，这个例子只向外yields值。但是当然，如果不用for-of循环，只是手动调用迭代器的next(),并且传递信息到里面，那些信息会以同样期望的方式通过yield*代理传递。

function *foo() {
    var z = yield 3;
    var w = yield 4;
    console.log( "z: " + z + ", w: " + w );
}

function *bar() {
    var x = yield 1;
    var y = yield 2;
    yield *foo(); // `yield*` delegates iteration control to `foo()`
    var v = yield 5;
    console.log( "x: " + x + ", y: " + y + ", v: " + v );
}

var it = bar();

it.next();      // { value:1, done:false }
it.next( "X" ); // { value:2, done:false }
it.next( "Y" ); // { value:3, done:false }
it.next( "Z" ); // { value:4, done:false }
it.next( "W" ); // { value:5, done:false }
// z: Z, w: W

it.next( "V" ); // { value:undefined, done:true }
// x: X, y: Y, v: V

即使我们只在这里演示了一层代理，*foo()没有理由不能为另外的生成器迭代器yield代理，然后再一个，以此类推。

另外一个yield可以玩的把戏是从代理生成器接收return值。

function *foo() {
    yield 2;
    yield 3;
    return "foo"; // return value back to `yield*` expression
}

function *bar() {
    yield 1;
    var v = yield *foo();
    console.log( "v: " + v );
    yield 4;
}

var it = bar();

it.next(); // { value:1, done:false }
it.next(); // { value:2, done:false }
it.next(); // { value:3, done:false }
it.next(); // "v: foo"   { value:4, done:false }
it.next(); // { value:undefined, done:true }

可以看到，yield *foo()代理了迭代控制（next()调用）直到他结束，然后来自foo()的任何返回值被置为yield*表达式的结果，然后赋值给了本地变量v.

yield和yield *有一个有意思的区别：用yield表达式，结果是被随后的next()送进来的，但是用yield*，它只从它的代理的return值接受结果。

也可以从两个方向上进行错误处理，通过yield*代理：

function *foo() {
    try {
        yield 2;
    }
    catch (err) {
        console.log( "foo caught: " + err );
    }

    yield; // pause

    // now, throw another error
    throw "Oops!";
}

function *bar() {
    yield 1;
    try {
        yield *foo();
    }
    catch (err) {
        console.log( "bar caught: " + err );
    }
}

var it = bar();

it.next(); // { value:1, done:false }
it.next(); // { value:2, done:false }

it.throw( "Uh oh!" ); // will be caught inside `foo()`
// foo caught: Uh oh!

it.next(); // { value:undefined, done:true }  --> No error here!
// bar caught: Oops!

可以看到，throw("Uh oh!")在*foo()内通过yield*代理抛错到了try-catch。在*foo()内的throw "Oops!"抛出来回到了*bar(),然后通过另外一个try-catch捕获了。要是没有捕获到他们其中的一个，错误会像期望的那样继续向外传播。

总结

生成器有同步处理机制，即可以通过yield声明使用try-catch错误处理。生成器迭代器也有一个throw()方法在生成器暂停的位置抛错,当然也可以被生成器内部的try-catch捕获。

yield允许从当前的生成器为另外一个代理迭代控制。结果是yield*在两个方向上传递，可以是信息也可以是错误。

但是，还有一个基本问题遗留了，没有回答：生成器怎么通过同步代码模式帮助我们？所有我们现在看到的这两篇文章是生成器函数的同步迭代器。

关键是构建一个生成器暂停来启动异步任务的机制，然后在异步任务最后恢复。我们将探讨很多通过生成器生成这样异步控制的方法。
英文原文：http://davidwalsh.name/es6-generators-dive