我认为你走在正确的轨道上，你只需要调整一些东西。我会向app.use()注册一个顶级函数，然后在该函数中执行所有动态操作。将我的答案更新为一个工作示例。请务必先安装异步npm install --save async

// define all middleware functions
var middleware = {
    mw1: function(req, res, next) {
        console.log('mw 1');
        next();
    },
    mw2: function(req, res, next) {
        console.log('mw 2');
        next();
    },
    mw3: function(req, res, next) {
        console.log('mw 3');
        next();
    },
    mw4: function(req, res, next) {
        console.log('mw 4');
        next();
    }
};
// register our "top level function"
app.use(configurableMiddleware);
var requestCount = 1; // this is just for the working example
function configurableMiddleware(req, res, next) {
    var isEvenRequest = requestCount++ % 2 === 0; // simple logic to alternate which "configurable" middleware to use
    var operations; // in the real world you could build this array dynamically, for now we just hardcode two scenarios as an example
    // Each request to http://localhost:3000 will alternate which middleware is used, so you will see a different log each time
    if(isEvenRequest) {
        console.log('Even request should log mw2 and mw4');
        // .bind(null, req, res) makes sure that the middleware gets the request and response objects when they are invoked, 
        // as of this point they still haven't been invoked...
        operations = [middleware.mw2.bind(null, req, res), middleware.mw4.bind(null, req, res)];
    }
    else {
        console.log('Odd request should log mw1 and mw3');
        operations = [middleware.mw1.bind(null, req, res), middleware.mw3.bind(null, req, res)];
    }
    // invoke each middleware in series - you could also do async.parallel if the order of middleware doesn't matter
    // using the async module: https://github.com/caolan/async
    async.series(operations, function(err) {
        if(err) {
            console.log('There was a problem running the middleware!');
            return next(err);
        }
        // all middleware has been run
        next();
    });
}

有关 .bind（） 的更多信息，请参阅 https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind

用于该特定目的的专用节点模块：

您可以只使用为此目的而设计的模块connect-sequence：

npm install --save connect-sequence

看：

• NPMJS 页面：https://www.npmjs.com/package/connect-sequence
• 或 GitHub 项目：https://github.com/sirap-group/connect-sequence

然后，这里有一个用法示例：

/**
 * Product API
 * @module
 */
var ConnectSequence = require('connect-sequence')
var productsController = require('./products.controller')
module.exports = productRouter
function productRouter (app) {
  app.route('/api/products/:productId')
  .get(function (req, res, next) {
    // Create a ConnectSequence instance and setup it with the current `req`,
    // `res` objects and the `next` callback
    var seq = new ConnectSequence(req, res, next)
    // build the desired middlewares sequence thanks to:
    // - ConnectSequence#append(mid0, ..., mid1),
    // - ConnectSequence#appendList([mid0, ..., mid1])
    // - and ConnectSequence#appendIf(condition, mid)
    if (req.query.filter) {
      seq.append(productsController.filter)
    }
    if (req.query.format) {
      seq.append(
        productsController.validateFormat,
        productsController.beforeFormat,
        productsController.format,
        productsController.afterFormat
      )
    }
    // append the productsController.prepareResponse middleware to the sequence
    // only if the condition `req.query.format && req.formatedProduct` is true
    // at the moment where the middleware would be called.
    // So the condition is tested after the previous middleware is called and thus
    // if the previous modifies the `req` object, we can test it.
    seq.appendIf(isProductFormatted, productsController.prepareResponse)
    seq.append(productsController.sendResponse)
    // run the sequence
    seq.run()
  })
  app.param('productId', function (req, res, next, id) {
    // ... yield the product by ID and bind it to the req object
  })
  function isProductFormatted (req) {
    return Boolean(req.formatedProduct)
  }
}

这是开源的，欢迎公关！

如果您喜欢并使用连接序列，但如果您发现错误或需要一些新功能，请随时发布问题或提交拉取请求！

基于@Ryan代码背后的想法，我想出了这个函数。它根据需要按顺序绑定变量执行中间件列表，允许仅通过executeMiddlewareList([middleware1, middleware2...], req, res, next);执行所有内容。对于每个中间件，传递req, res，并从async.eachSeries回调。这意味着当在中间件内部调用next()时，将从列表中处理下一个。如果中间件抛出 next(err) 错误，执行将停止，您可以手动处理此问题。

function executeMiddlewareList (middlewareList, req, res, next) {
   async.eachSeries(middlewareList, function(middleware,callback) {
      middleware.bind(null,req,res,callback)()
   }, function(err) {
      if (err) return res.status(500).json({error: err});
      next();
   })
}
function testMid (number) {
   return function (req, res, next) {
      log.debug('req.test from', req.test, " to ", number);
      req.test=number;
      next();
   }
}
router.get('/test', function(req, res, next) {
   m.executeMiddlewareList([test(1), test(2)], req, res, next);
   //Output: req.test from undefined to 1
   //        req.test from 1 to 2
}, function (req,res) {
    //Do stuff after the executeMiddlewareList, req.test = 2
})

最后，我根据 Ryan 找到了答案，代码如下所示：

function configurableMiddleWare(req, res, next) {
    var operations = [];
    var middleware;
    var sortedConfig = sortConfig(confirguration);
   // push each middleware you want to run
    sortedConfig.forEach(function(fn) {
        switch(fn[0]){
            case 'before1':
                middleware = before1;
                break;
            case 'before2':
                middleware = before2;
                break;
            case 'service':
                middleware = fakeRequest;
                break;
            case 'after1':
                middleware = after1;
                break;
            case 'after2':
                middleware = after2;
                break;
        }
        console.log(fn[0]);
        console.log(middleware);
        operations.push(middleware.bind(null, req, res)); // could use fn.bind(null, req, res) to pass in vars  
    });
    console.log('middleware list sorted');
   // now actually invoke the middleware in series
    async.series(operations, function(err) {
        if(err) {
        // one of the functions passed back an error so handle it here
            return next(err);
        }
        console.log('middleware get executed');
        // no errors so pass control back to express
        next();
    });
}
app.use('/test', configurableMiddleWare);

关键一步确实是operations.push(middleware.bind(null, req, res));老实说，我不明白这到底是什么意思。我知道这是将"req"和"res"变量传递到中间件中，但我不明白前面"null"的意义。如果有人能帮助我澄清这一点，非常感谢。