理解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