详解Node.js中的Async和Await函数

在本文中，你将学习如何使用node.js中的async函数(async/await)来简化callback或promise.

异步语言结构在其他语言中已经存在了，像c#的async/await、kotlin的coroutines、go的goroutines，随着node.js 8的发布，期待已久的async函数也在其中默认实现了。

node中的async函数是什么？

当函数声明为一个async函数它会返回一个 asyncfunction 对象，它们类似于 generator 因为执可以被暂停。唯一的区别是它们返回的是 promise 而不是 { value: any, done: boolean } 对象。不过它们还是非常相似，你可以使用 co 包来获取同样的功能。

在async函数中，可以等待 promise 完成或捕获它拒绝的原因。

如果你要在promise中实现一些自己的逻辑的话

function handler (req, res) {
 return request('https://user-handler-service')
 .catch((err) => {
  logger.error('http error', err)
  error.logged = true
  throw err
 })
 .then((response) => mongo.findone({ user: response.body.user }))
 .catch((err) => {
  !error.logged && logger.error('mongo error', err)
  error.logged = true
  throw err
 })
 .then((document) => executelogic(req, res, document))
 .catch((err) => {
  !error.logged && console.error(err)
  res.status(500).send()
 })
}

可以使用 async/await 让这个代码看起来像同步执行的代码

async function handler (req, res) {
 let response
 try {
 response = await request('https://user-handler-service') 
 } catch (err) {
 logger.error('http error', err)
 return res.status(500).send()
 }
 let document
 try {
 document = await mongo.findone({ user: response.body.user })
 } catch (err) {
 logger.error('mongo error', err)
 return res.status(500).send()
 }
 executelogic(document, req, res)
}

在老的v8版本中，如果有有个 promise 的拒绝没有被处理你会得到一个警告，可以不用创建一个拒绝错误监听函数。然而，建议在这种情况下退出你的应用程序。因为当你不处理错误时，应用程序处于一个未知的状态。

process.on('unhandledrejection', (err) => { 
 console.error(err)
 process.exit(1)
})

async函数模式

在处理异步操作时，有很多例子让他们就像处理同步代码一样。如果使用 promise 或 callbacks 来解决问题时需要使用很复杂的模式或者外部库。

当需要再循环中使用异步获取数据或使用 if-else 条件时就是一种很复杂的情况。

指数回退机制

使用 promise 实现回退逻辑相当笨拙

function requestwithretry (url, retrycount) {
 if (retrycount) {
 return new promise((resolve, reject) => {
  const timeout = math.pow(2, retrycount)
  settimeout(() => {
  console.log('waiting', timeout, 'ms')
  _requestwithretry(url, retrycount)
   .then(resolve)
   .catch(reject)
  }, timeout)
 })
 } else {
 return _requestwithretry(url, 0)
 }
}
function _requestwithretry (url, retrycount) {
 return request(url, retrycount)
 .catch((err) => {
  if (err.statuscode && err.statuscode >= 500) {
  console.log('retrying', err.message, retrycount)
  return requestwithretry(url, ++retrycount)
  }
  throw err
 })
}
requestwithretry('http://localhost:3000')
 .then((res) => {
 console.log(res)
 })
 .catch(err => {
 console.error(err)
 })

代码看的让人很头疼，你也不会想看这样的代码。我们可以使用async/await重新这个例子，使其更简单

function wait (timeout) {
 return new promise((resolve) => {
 settimeout(() => {
  resolve()
 }, timeout)
 })
}

async function requestwithretry (url) {
 const max_retries = 10
 for (let i = 0; i <= max_retries; i++) {
 try {
  return await request(url)
 } catch (err) {
  const timeout = math.pow(2, i)
  console.log('waiting', timeout, 'ms')
  await wait(timeout)
  console.log('retrying', err.message, i)
 }
 }
}

上面代码看起来很舒服对不对

中间值

不像前面的例子那么吓人，如果你有3个异步函数依次相互依赖的情况，那么你必须从几个难看的解决方案中进行选择。

functiona 返回一个 promise ，那么 functionb 需要这个值而 functioinc 需要 functiona 和 functionb 完成后的值。

方案1： then 圣诞树

function executeasynctask () {
 return functiona()
 .then((valuea) => {
  return functionb(valuea)
  .then((valueb) => {   
   return functionc(valuea, valueb)
  })
 })
}

用这个解决方案，我们在第三个 then 中可以获得 valuea 和 valueb ，然后可以向前面两个 then 一样获得 valuea 和 valueb 的值。这里不能将圣诞树(毁掉地狱)拉平，如果这样做的话会丢失闭包， valuea 在 functioinc 中将不可用。

方案2：移动到上一级作用域

function executeasynctask () {
 let valuea
 return functiona()
 .then((v) => {
  valuea = v
  return functionb(valuea)
 })
 .then((valueb) => {
  return functionc(valuea, valueb)
 })
}

在这颗圣诞树中，我们使用更高的作用域保变量 valuea ，因为 valuea 作用域在所有的 then 作用域外面，所以 functionc 可以拿到第一个 functiona 完成的值。

这是一个很有效扁平化 .then 链"正确"的语法，然而，这种方法我们需要使用两个变量 valuea 和 v 来保存相同的值。

方案3：使用一个多余的数组

function executeasynctask () {
 return functiona()
 .then(valuea => {
  return promise.all([valuea, functionb(valuea)])
 })
 .then(([valuea, valueb]) => {
  return functionc(valuea, valueb)
 })
}

在函数 functiona 的 then 中使用一个数组将 valuea 和 promise 一起返回，这样能有效的扁平化圣诞树(回调地狱)。

方案4：写一个帮助函数

const converge = (...promises) => (...args) => {
 let [head, ...tail] = promises
 if (tail.length) {
 return head(...args)
  .then((value) => converge(...tail)(...args.concat([value])))
 } else {
 return head(...args)
 }
}
functiona(2)
 .then((valuea) => converge(functionb, functionc)(valuea))

这样是可行的，写一个帮助函数来屏蔽上下文变量声明。但是这样的代码非常不利于阅读，对于不熟悉这些魔法的人就更难了。

使用 async/await 我们的问题神奇般的消失

async function executeasynctask () {
 const valuea = await functiona()
 const valueb = await functionb(valuea)
 return function3(valuea, valueb)
}

使用 async/await 处理多个平行请求

和上面一个差不多，如果你想一次执行多个异步任务，然后在不同的地方使用它们的值可以使用 async/await 轻松搞定。

async function executeparallelasynctasks () {
 const [ valuea, valueb, valuec ] = await promise.all([ functiona(), functionb(), functionc() ])
 dosomethingwith(valuea)
 dosomethingelsewith(valueb)
 doanotherthingwith(valuec)
}

数组迭代方法

你可以在 map 、 filter 、 reduce 方法中使用async函数，虽然它们看起来不是很直观，但是你可以在控制台中实验以下代码。

1.map

function asyncthing (value) {
 return new promise((resolve, reject) => {
 settimeout(() => resolve(value), 100)
 })
}

async function main () {
 return [1,2,3,4].map(async (value) => {
 const v = await asyncthing(value)
 return v * 2
 })
}

main()
 .then(v => console.log(v))
 .catch(err => console.error(err))

2.filter

function asyncthing (value) {
 return new promise((resolve, reject) => {
 settimeout(() => resolve(value), 100)
 })
}
async function main () {
 return [1,2,3,4].filter(async (value) => {
 const v = await asyncthing(value)
 return v % 2 === 0
 })
}
main()
 .then(v => console.log(v))
 .catch(err => console.error(err))

3.reduce

function asyncthing (value) {
 return new promise((resolve, reject) => {
 settimeout(() => resolve(value), 100)
 })
}
async function main () {
 return [1,2,3,4].reduce(async (acc, value) => {
 return await acc + await asyncthing(value)
 }, promise.resolve(0))
}
main()
 .then(v => console.log(v))
 .catch(err => console.error(err))

解决方案：

[ promise { <pending> }, promise { <pending> }, promise { <pending> }, promise { <pending> } ]
[ 1, 2, 3, 4 ]
10

如果是map迭代数据你会看到返回值为 [ 2, 4, 6, 8 ] ，唯一的问题是每个值被 asyncfunction 函数包裹在了一个 promise 中

所以如果想要获得它们的值，需要将数组传递给 promise.all() 来解开 promise 的包裹。

main()
 .then(v => promise.all(v))
 .then(v => console.log(v))
 .catch(err => console.error(err))
一开始你会等待 promise 解决，然后使用map遍历每个值
function main () {
 return promise.all([1,2,3,4].map((value) => asyncthing(value)))
}
main()
 .then(values => values.map((value) => value * 2))
 .then(v => console.log(v))
 .catch(err => console.error(err))

这样好像更简单一些？

如果在你的迭代器中如果你有一个长时间运行的同步逻辑和另一个长时间运行的异步任务，async/await版本任然常有用

这种方式当你能拿到第一个值，就可以开始做一些计算，而不必等到所有 promise 完成才运行你的计算。尽管结果包裹在 promise 中，但是如果按顺序执行结果会更快。

关于 filter 的问题

你可能发觉了，即使上面filter函数里面返回了 [ false, true, false, true ] ， await asyncthing(value) 会返回一个 promise 那么你肯定会得到一个原始的值。你可以在return之前等待所有异步完成，在进行过滤。

reducing很简单，有一点需要注意的就是需要将初始值包裹在 promise.resolve 中

重写基于callback的node应用成

async 函数默认返回一个 promise ，所以你可以使用 promises 来重写任何基于 callback 的函数，然后 await 等待他们执行完毕。在node中也可以使用 util.promisify 函数将基于回调的函数转换为基于 promise 的函数

重写基于promise的应用程序

要转换很简单， .then 将promise执行流串了起来。现在你可以直接使用`async/await。

function asynctask () {
 return functiona()
  .then((valuea) => functionb(valuea))
  .then((valueb) => functionc(valueb))
  .then((valuec) => functiond(valuec))
  .catch((err) => logger.error(err))
}

转换后

async function asynctask () {
 try {
  const valuea = await functiona()
  const valueb = await functionb(valuea)
  const valuec = await functionc(valueb)
  return await functiond(valuec)
 } catch (err) {
  logger.error(err)
 }
}
rewriting nod

使用 async/await 将很大程度上的使应用程序具有高可读性，降低应用程序的处理复杂度(如：错误捕获)，如果你也使用 node v8+的版本不妨尝试一下，或许会有新的收获。

总结

以上所述是小编给大家介绍的node.js中的async和await函数，希望对大家有所帮助