理解Koa2中的async&await

Z_Xu發表於2019-02-27
AI

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

相關文章