洋葱模型

洋葱模型是一种中间件流程控制方式。

洋葱模型

这是 koa.js 的示例代码：

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

app.use(async (ctx, next) => {
  console.log('中间件 1 进入');
  await next();
  console.log('中间件 1 退出');
});

app.use(async (ctx, next) => {
  console.log('中间件 2 进入');
  await next();
  console.log('中间件 2 退出');
});

app.use(async (ctx, next) => {
  console.log('中间件 3');
});

app.listen(3000);

任意一个请求到来将输出如下的执行结果：

中间件 1 进入
中间件 2 进入
中间件 3 
中间件 2 退出
中间件 1 退出

koa 在内部维护了一个中间件数组：

this.middleware = [];

调用 use 就是在给数组新增一项：

use(fn) {
    this.middleware.push(fn);
    return this;
}

如何让中间件数组以洋葱模型调用呢？

使用递归实现是很简单的

const m1 = (ctx, next) => {
    ctx.req.user = null;
    console.log('中间件1 进入', ctx.req);

    next()

    console.log('中间件1 退出', ctx.req);
}

const m2 = (ctx, next) => {
    ctx.req.user = { id: 1 };
    console.log('中间件2 进入');

    next()

    console.log('中间件2 退出');
}

const m3 = (ctx, next) => {
    console.log('中间件3');
}

const middlewares = [m1, m2, m3];
const context = { req: {}, res: {} };

function dispatch(i) {
    if (i === middlewares.length) return;
    return middlewares[i](context, () => dispatch(i + 1));
}

dispatch(0);

输出结果如下：

中间件1 进入 { user: null }
中间件2 进入
中间件3
中间件2 退出
中间件1 退出 { user: { id: 1 } }

koa 的中间件都是异步函数，它做了对异步函数的相关处理：

    let index = -1
    function dispatch (i) {
      index = i
      let fn = middleware[i]
      if (i === middleware.length) fn = next
      if (!fn) return Promise.resolve()
      try {
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
      } catch (err) {
        return Promise.reject(err)
      }
    }
 

尾递归

递归函数会保留父级作用域的调用栈，如果层级很深它就会导致堆栈溢出。而尾递归则可以进行优化，在 express.js 中就是使用的尾递归实现中间件流程控制的。

const m1 = (req, res, next) => {
    req.user = null;
    console.log('中间件1 进入', req);

    next();

    console.log('中间件1 退出', req);
}

const m2 = (req, res, next) => {
    req.user = { id: 1 };
    console.log('中间件2 进入');

    next();

    console.log('中间件2 退出');
}

const m3 = (req, res, next) => {
    console.log('中间件3');
}

const middlewares = [m1, m2, m3];

const req = {};
const res = {};

let idx = 0;

function next(err) {
    if (idx >= middlewares.length) return;

    let m;

    while (idx < middlewares.length) {
        m = middlewares[idx++];
        m(req, res, next);
    }
}

next();

输出结果如下：

中间件1 进入 { user: null }
中间件2 进入
中间件3
中间件2 退出
中间件1 退出 { user: { id: 1 } }

尾递归可以被优化成循环，这样每次执行完调用栈就会被释放，也就不会导致堆栈溢出了。
尽管尾调用优化是ECMAScript 2015规范的一部分，但是大多数JavaScript解释器都不支持它。