Express之next()

March 4, 2024

定义

express 的 next() 函数类型如下

export interface NextFunction {
    (err?: any): void;
    /**
     * "Break-out" of a router by calling {next('router')};
     * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.router}
     */
    (deferToNext: "router"): void;
    /**
     * "Break-out" of a route by calling {next('route')};
     * @see {https://expressjs.com/en/guide/using-middleware.html#middleware.application}
     */
    (deferToNext: "route"): void;
}

实现

express 的 next() 函数可能稍显复杂，不妨先看看 koa 的 next() 函数，通过 koa-compose 包实现（另见此处），其代码比 express 简洁，并且更好地支持异步中间件

function (context, next) {
    // last called middleware #
    let index = -1
    return dispatch(0)
    function dispatch (i) {
      if (i <= index) return Promise.reject(new Error('next() called multiple times'))
      index = i
      let fn = middleware[i]
      if (i === middleware.length) fn = next // 若当前已运行所有中间件
      if (!fn) return Promise.resolve() // 如果没有调用 next 函数，停止运行
      try {
        return Promise.resolve(fn(context, dispatch.bind(null, i + 1))) // 运行下一个中间件
      } catch (err) {
        return Promise.reject(err)
      }
    }
}

再简化（next() 函数无 err 参数）

const next = /* async */ () => {
    let mw;
    while (!mw && mwArray.length > 0) {
        mw = mwArray.shift(); // 添加时 push()
    }
    /* await */ mw?.(req, res, next);
};

注意： express 实际继承自 EventEmitter，就和 Node.js 中其它异步机制一样，不关心回调函数是否异步
对于 express，缺点在于中间件内部抛出的异常必须通过 next() 函数手动捕获

express 的 next() 函数如下：
https://github.com/expressjs/express/blob/master/lib/router/route.js

Route.prototype.dispatch = function dispatch(req, res, done) {
    var idx = 0;
    var stack = this.stack;
    var sync = 0;

    if (stack.length === 0) {
        return done();
    }
    var method = typeof req.method === "string" ? req.method.toLowerCase() : req.method;

    if (method === "head" && !this.methods["head"]) {
        method = "get";
    }

    req.route = this;

    next();

    function next(err) {
        // signal to exit route
        if (err && err === "route") {
            return done();
        }

        // signal to exit router
        if (err && err === "router") {
            return done(err);
        }

        // max sync stack
        if (++sync > 100) {
            return setImmediate(next, err);
        }

        var layer = stack[idx++];

        // end of layers
        if (!layer) {
            return done(err);
        }

        if (layer.method && layer.method !== method) {
            next(err);
        } else if (err) {
            layer.handle_error(err, req, res, next);
        } else {
            layer.handle_request(req, res, next);
        }

        sync = 0;
    }
};