理解Koa2中的async&await

Koa是一款很是著名的Node服务端框架，有1.x版本和2.x版本。前者使用了generator来进行异步操做，后者则用了最新的async/await方案

一开始使用这种写法的时候，我遇到一个问题，代码以下：

const Koa = require('koa');
const app = new Koa();

const doSomething = time => {
    return new Promise(resolve => {
        setTimeout(() => {
            resolve('task done!')
        }, time)
    })
}

// 用来打印请求信息
app.use((ctx, next) => {
    console.log(`${ctx.method}:::${ctx.url}`)
    next()
})

app.use(async ctx => {
    const result = await doSomething(3000)
    console.log(result);
    ctx.body = result
})

app.listen(3000);
复制代码

让咱们测试一下：

curl http://localhost:3000
复制代码

指望结果：

(3秒后...)task done!
复制代码

然而现实倒是：

(当即)
Not Found
复制代码

什么鬼？为何没有按照预期执行？这就须要咱们来理解下Koa中中间件是如何串联起来的了。翻一下源码，将middlewares串联起来的代码以下：

function compose (middleware) {
  return function (context, next) {
    // 这个index用来计数，防止next被屡次调用
    let index = -1
    // 执行入口
    return dispatch(0)
    
    function dispatch (i) {
      // 若是next被屡次调用，报异常
      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
      index = i
      // 取出第一个middleware
      let fn = middleware[i]
      // 将最初传入的next做为最后一个函数执行
      if (i === middleware.length) fn = next
      if (!fn) return Promise.resolve()
      try {
        /** 这里就是关键了,Promise.resolve是什么意思呢？ Promise.resolve方法有下面三种形式： Promise.resolve(value); Promise.resolve(promise); Promise.resolve(theanable); 这三种形式都会产生一个新的Promise。其中： 第一种形式提供了自定义Promise的值的能力，它与Promise.reject(reason)对应。二者的不一样，在于获得的Promise的状态不一样。 第二种形式，提供了建立一个Promise的副本的能力。 第三种形式，是将一个相似Promise的对象转换成一个真正的Promise对象。它的一个重要做用是将一个其余实现的Promise对象封装成一个当前实现的Promise对象。例如你正在用bluebird，可是如今有一个Q的Promise，那么你能够经过此方法把Q的Promise变成一个bluebird的Promise。第二种形式能够归在第三种里面 **/
        return Promise.resolve(fn(context, function next () {
          // 执行下一个middleware，返回结果也是一个Promise
          return dispatch(i + 1)
        }))
      } catch (err) {
        return Promise.reject(err)
      }
    }
  }
}
复制代码

有了以上基础，咱们再来看一下以前的问题，为何response没有等到第二个middleware执行完成就当即返回了呢？

由于第一个middleware并非一个异步函数啊。

因为每次next方法的执行，实际上都是返回了一个Promise对象，因此若是咱们在某个middleware中执行了异步操做，要想等待其完成，就要在执行这个middleware以前添加await

那咱们来改写一下以前的代码

app.use(async (ctx, next) => {
    console.log(`${ctx.method}:::${ctx.url}`)
    await next()
})

app.use(async ctx => {
    const result = await doSomething(3000)
    console.log(result);
    ctx.body = result
})
复制代码

好了，没有问题，一切如指望执行👏

错误处理

借助了Promise强大的功力，配合async/await语法，咱们只须要把try/catch的操做写在最外层的middleware中，就能够捕获到以后全部中间件的异常！

app.use(async (ctx, next) => {
    try{
        await next()
    }catch(err){
        console.log(err)
    }
})

app.use(async (ctx)=>{
    throw new Error('something wrong!')
    ctx.body = 'Hello'
})
复制代码

基于中间件链的彻底控制，而且基于 Promise 的事实使得一切都变得容易操做起来。再也不是处处的 if (err) return next(err) 而只有 promise