async/await 和 generators 有哪些不同

async/await 是 es2017 的重要新特性。async/await 和 es2015 发布的 generators 有很多相似之处。在 stackoverflow 有很多关于这两者不同之处的提问，其中也有一些不错的回答。
如果你用过 co 模块，基于 generator 的代码看起来会很像 async/await。

以下是 async/await 处理 HTTP 请求三次。

async function test() {
  let i
  for (i = 0; i < 3; ++i) {
    try {
      await superagent.get('http://google.com/this-throws-an-error')
      break
    } catch (err) {}
  }
  console.log(i) // 3
}

相同功能的 generator 实现：

const test = co.wrap(function*() {
  let i
  for (i = 0; i < 3; ++i) {
    try {
      yield superagent.get('http://bad.domain')
      break
    } catch (err) {}
  }
  console.log(i) // 3
})

通过观察，你可以写一个将 async/await 转换成 generators 的转换器，原理就是将 async function() {}替换成 co.wrap(function*() {})，将 await 替换为 yield。 所以这两者到底有什么不同？

不同点

很重要的一点不同是 generators 在 Node.js 4.x 就开始支持，而 async/await 要求 Node.js >= 7.6.0。不过 Node.js 4.x 早就不再维护，Node.js 6.x 也在 2019 年终止维护， 所以这个不同点现在没那么重要了。

另一点不同是 co 模块是开发者维护的第三方模块，而 async/await 是 js 语言的一部分。所以你需要将 co 写到 package.json 里，而 async/await 则不需要，不过如果你想支持老旧的浏览器，你就需要配置一下转换器。

stack traces 得到的错误不同。async/await 得到的错误比 generators 要清晰。而且，由于 async/await 是 JavaScript 语言的核心部分，而不是像 co 这样的用户级库，因此将来可能会对 async/await 堆栈跟踪进行更多改进。

这里有个例子展示 async 函数抛出的错误。

async function runAsync() {
  await new Promise(resolve => setTimeout(() => resolve(), 100))
  throw new Error('Oops!')
}

// Error: Oops!
//    at runAsync (/home/val/test.js:5:9)
//    at <anonymous>
runAsync().catch(error => console.error(error.stack))

以下是用 generators 实现的相同功能，注意错误里出现的 onFulfilled() 和 Generator.next() 透漏了 co 模块是怎么工作的。

const co = require('co')

const runCo = co.wrap(function*() {
  yield new Promise(resolve => setTimeout(() => resolve(), 100))
  throw new Error('Oops!')
})

// Error: Oops!
//     at D:\code\js\test\babel-test\src\co_test.js:5:9
//     at Generator.next (<anonymous>)
//     at onFulfilled (D:\code\js\test\babel-test\node_modules\co\index.js:65:19)
runCo().catch(error => console.error(error.stack))

Thunks 和 Promise 转换

async/await 仅仅用于 Promise, 如果用于非 Promise 是没有用的。

async function runAsync() {
  // res 将会是一个 function
  // 因为 function 不是 promise，所以括号是语法所必需的
  const res = await (cb => cb(null, 'test'))
  console.log(res)
}

runAsync().catch(error => console.error(error.stack))

另一方来看，co 将 yield 的值转成 Promise。当你 yield 带有单个参数的函数，即 Node.js 样式的回调，co 会把它转成 promise。

const co = require('co')

const runCo = co.wrap(function*() {
  // `res` will be a string, because co converts the
  // value you `yield` into a promise. The `yield cb => {}`
  // pattern is called a _thunk_.
  const res = yield cb => cb(null, 'test')
  console.log(res)
})

runCo().catch(error => console.error(error.stack))

同样，co 也可以起到 Promise.all() 相似的效果。

async function runAsync() {
  // 用 co 的话，你可以写
  // `yield [Promise.resolve('v1'), Promise.resolve('v2')]`
  const res = await Promise.all([
    Promise.resolve('v1'),
    Promise.resolve('v2');
  ]);
  // 'v1 v2'
  console.log(res[0], res[1]);
}

第三方库的好处

在许多时候，generators 是 async/await 的超集。用 generators，你可以使用它的一些强大特性转换成你自己的 async/await. Co 内置的 Promise 转换只是冰山一角。举个例子，我曾经建立了一个类似 co 的库，该库返回了一个可观察的对象。使用 RxJS 的 filter 运算符，处理错误将非常容易。

const corx = require('./')
require('rxjs/add/operator/filter')

corx(function*() {
  yield Promise.resolve('Test 1')
  try {
    yield Promise.reject('Test 2')
  } catch (error) {}
  console.log('Reached the end')
})
  .filter(v => !!v)
  .subscribe(
    op$ => {
      // This will print, even though the error was caught, because
      // this callback executes on every single async operation!
      op$.subscribe(
        () => {},
        err => console.log('Error occurred', err)
      )
    },
    error => console.log('This will not print'),
    () => console.log('Done')
  )

上面的杀手级功能是，当 subscribe() 时，generator 函数中发生的每个异步操作都会获得一个回调。
这意味着您可以在不实际更改任何逻辑的情况下，通过 debugging, profiling, error handling 来检测每个单独的异步操作！

这个特性很酷，但是还不足以让我们抛弃 async/await 用 generator。async/await 的优点在于它在大部分时间都满足您的需求，而这个基于 observable 的库实际上将为您解决什么问题？
为了使调试起作用，您将需要一种从可观察的 op$ 中提取有意义的信息的方法，在一般情况下，除了这种我从来没有找到其他方法。

这就是为什么我要重新看重middleware，将其作为解决跨领域问题的正确工具。

另外，对于 async/await 的适用情况，可观察对象可能并不是很好的选择，因为它们会解释为多个值，甚至可能是无限值的循环。

总结

async/await 和 generators 乍一看很相似，但两者之间存在许多有意义的差异。

async/await 不需要第三方库，看起来更简洁；generators 通常要配合第三方库使用，但是这些第三方库又提供了很多 async/await 不具备的强大的功能。换句话说，async/await 和 generators 之间的权衡就是简洁与灵活之间的权衡。

作为高级开发人员，您可以在某些情况下从开发人员那里获得有意义的价值，但是大多数情况下，async/await 是更好的选择。