async/await 和 ES6 生成器的收益之间的区别

我刚刚读了这篇精彩的文章 «发电机 https://www.promisejs.org/generators» 它清楚地突出显示了这个函数，它是一个用于处理生成器函数的辅助函数：

function async(makeGenerator){
  return function () {
    var generator = makeGenerator.apply(this, arguments);

    function handle(result){
      // result => { done: [Boolean], value: [Object] }
      if (result.done) return Promise.resolve(result.value);

      return Promise.resolve(result.value).then(function (res){
        return handle(generator.next(res));
      }, function (err){
        return handle(generator.throw(err));
      });
    }

    try {
      return handle(generator.next());
    } catch (ex) {
      return Promise.reject(ex);
    }
  }
}

我假设这或多或少是这样的async关键字的实现是async/await.那么问题来了，如果是这样的话，那么两者之间到底有什么区别呢？await关键字和yield关键词？做await总是把某事变成承诺，而yield没有做出这样的保证吗？这是我最好的猜测！

您还可以查看如何async/await类似于yield在这篇文章中使用生成器，他描述了“spawn”函数ES7 异步函数 https://jakearchibald.com/2014/es7-async-functions.

嗯，事实证明，两者之间有着非常密切的关系。async/await和发电机。而且我相信async/await将始终建立在发电机上。如果你看看 Babel 转译的方式async/await:

巴别塔采取了这个：

this.it('is a test', async function () {

    const foo = await 3;
    const bar = await new Promise(resolve => resolve('7'));
    const baz = bar * foo;
    console.log(baz);

});

并将其变成这样

function _asyncToGenerator(fn) {
    return function () {
        var gen = fn.apply(this, arguments);
        return new Promise(function (resolve, reject) {
            function step(key, arg) {
                try {
                    var info = gen[key](arg);
                    var value = info.value;
                } catch (error) {
                    reject(error);
                    return;
                }
                if (info.done) {
                    resolve(value);
                } else {
                    return Promise.resolve(value).then(function (value) {
                        return step("next", value);
                    }, function (err) {
                        return step("throw", err);
                    });
                }
            }

            return step("next");
        });
    };
}


this.it('is a test', _asyncToGenerator(function* () {   // << now it's a generator

    const foo = yield 3;    //  <<< now it's yield, not await
    const bar = yield new Promise(resolve => resolve(7));
    const baz = bar * foo;
    console.log(baz);

}));

你算一下。

这使得它看起来像async关键字只是包装函数，但如果是这样的话await只是变成了yield，当他们成为本地人后，图片可能会更多一些。

您可以在这里查看更多解释：https://www.promisejs.org/generators/ https://www.promisejs.org/generators/