Express 和 Koa 的中间件有什么区别？手写洋葱模型

请求 ──> A 的前半段 ──> B 的前半段 ──> C（路由处理）
                                          │
响应 <── A 的后半段 <── B 的后半段 <───────┘
         （await next() 之后的代码，在下游全部完成后才执行）

function compose(middleware) {
  return function (ctx, next) {
    let index = -1 // 已经执行到的中间件下标
    function dispatch(i) {
      // 同一个中间件里第二次调用 next 时，i 不会大于 index
      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
      index = i
      // 所有中间件都执行完后，执行外部传入的 next（可以没有）
      const fn = i === middleware.length ? next : middleware[i]
      if (!fn) return Promise.resolve()
      try {
        // 把"执行下一个中间件"作为 next 传进去，返回值统一包装成 Promise
        return Promise.resolve(fn(ctx, () => dispatch(i + 1)))
      } catch (err) {
        // 同步抛出的错误也转成 rejected Promise，上游的 try/catch 才能捕获
        return Promise.reject(err)
      }
    }
    return dispatch(0)
  }
}

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms))
const log = []
await compose([
  async (ctx, next) => { log.push(1); await next(); log.push(6) },
  async (ctx, next) => { log.push(2); await next(); log.push(5) },
  async (ctx, next) => { log.push(3); await sleep(10); log.push(4) },
])({})
console.log(log.join(' ')) // 1 2 3 4 5 6

import Koa from 'koa'

const app = new Koa()

// 放在最外层：耗时统计 + 兜底的错误处理
app.use(async (ctx, next) => {
  const start = performance.now()
  try {
    await next()
  } catch (err) {
    ctx.status = err.status ?? 500
    // 4xx 的错误信息可以返回给客户端，5xx 只返回通用提示
    ctx.body = { message: err.expose ? err.message : '服务器内部错误' }
    ctx.app.emit('error', err, ctx) // 交给 app.on('error') 记录日志
  } finally {
    const ms = (performance.now() - start).toFixed(1)
    ctx.set('X-Response-Time', `${ms}ms`) // 响应还没发出，仍然可以设置响应头
    console.log(`${ctx.method} ${ctx.url} ${ctx.status} ${ms}ms`)
  }
})

app.use(async (ctx) => {
  if (ctx.path === '/error') ctx.throw(400, '参数错误')
  ctx.body = { ok: true }
})

app.on('error', (err) => console.error('请求出错：', err.message))
app.listen(3000)