有趣的观察。请注意，在 JavaScript 中，您通常可以用命名函数变量替换内联匿名回调函数。

下列：

http.createServer(function (req, res) {
   // inline callback function ...

   getSomeData(client, function (someData) {
      // another inline callback function ...

      getMoreData(client, function(moreData) {
         // one more inline callback function ...
      });
   });

   // etc ...
});

可以重写为如下所示：

var moreDataParser = function (moreData) {
   // date parsing logic
};

var someDataParser = function (someData) {
   // some data parsing logic

   getMoreData(client, moreDataParser);
};

var createServerCallback = function (req, res) {
   // create server logic

   getSomeData(client, someDataParser);

   // etc ...
};

http.createServer(createServerCallback);

但是，除非您计划在其他地方重用回调逻辑，否则阅读内联匿名函数通常要容易得多，如您的示例所示。它还将使您不必为所有回调查找名称。

另外请注意，正如@pst在下面的评论中指出的那样，如果您在内部函数中访问闭包变量，则上述内容将不是直接的翻译。在这种情况下，使用内联匿名函数更可取。

凯，只需使用这些module之一。

• flow-js
• 放克
• 期货
• 追星族
• 节点连续体
• 滑动
• 步
• 节点流入
• 异步.js
• 异步

它会变成这样：

dbGet('userIdOf:bobvance', function(userId) {
    dbSet('user:' + userId + ':email', 'bobvance@potato.egg', function() {
        dbSet('user:' + userId + ':firstName', 'Bob', function() {
            dbSet('user:' + userId + ':lastName', 'Vance', function() {
                okWeAreDone();
            });
        });
    });
});

进入这个：

flow.exec(
    function() {
        dbGet('userIdOf:bobvance', this);

    },function(userId) {
        dbSet('user:' + userId + ':email', 'bobvance@potato.egg', this.MULTI());
        dbSet('user:' + userId + ':firstName', 'Bob', this.MULTI());
        dbSet('user:' + userId + ':lastName', 'Vance', this.MULTI());

    },function() {
        okWeAreDone()
    }
);

在大多数情况下，我同意 Daniel Vassallo。如果您可以将复杂且深度嵌套的函数分解为单独的命名函数，那么这通常是一个好主意。对于在单个函数中执行此操作有意义的时候，您可以使用许多可用的 node.js 异步库之一。人们想出了很多不同的方法来解决这个问题，所以看看 node.js module页面，看看你的想法。

我自己为此编写了一个module，称为async.js。使用这个，上面的例子可以更新为：

http.createServer(function (req, res) {
  res.writeHead(200, {'Content-Type': 'text/html'});
  async.series({
    someData: async.apply(getSomeDate, client),
    someOtherData: async.apply(getSomeOtherDate, client),
    moreData: async.apply(getMoreData, client)
  },
  function (err, results) {
    var html = "<h1>Demo page</h1>";
    html += "<p>" + results.someData + "</p>";
    html += "<p>" + results.someOtherData + "</p>";
    html += "<p>" + results.moreData + "</p>";
    res.write(html);
    res.end();
  });
});

这种方法的一个好处是，您可以通过将“系列”函数更改为“并行”来快速更改代码以并行获取数据。更重要的是，async.js 也可以在浏览器中运行，因此如果遇到任何棘手的异步代码，您可以使用与在 node.js 中相同的方法。

希望有用！

您可以将此技巧用于数组而不是嵌套函数或module。

在眼睛上容易得多。

var fs = require("fs");
var chain = [
    function() { 
        console.log("step1");
        fs.stat("f1.js",chain.shift());
    },
    function(err, stats) {
        console.log("step2");
        fs.stat("f2.js",chain.shift());
    },
    function(err, stats) {
        console.log("step3");
        fs.stat("f2.js",chain.shift());
    },
    function(err, stats) {
        console.log("step4");
        fs.stat("f2.js",chain.shift());
    },
    function(err, stats) {
        console.log("step5");
        fs.stat("f2.js",chain.shift());
    },
    function(err, stats) {
        console.log("done");
    },
];
chain.shift()();

您可以扩展并行进程甚至并行进程链的习语：

var fs = require("fs");
var fork1 = 2, fork2 = 2, chain = [
    function() { 
        console.log("step1");
        fs.stat("f1.js",chain.shift());
    },
    function(err, stats) {
        console.log("step2");
        var next = chain.shift();
        fs.stat("f2a.js",next);
        fs.stat("f2b.js",next);
    },
    function(err, stats) {
        if ( --fork1 )
            return;
        console.log("step3");
        var next = chain.shift();

        var chain1 = [
            function() { 
                console.log("step4aa");
                fs.stat("f1.js",chain1.shift());
            },
            function(err, stats) { 
                console.log("step4ab");
                fs.stat("f1ab.js",next);
            },
        ];
        chain1.shift()();

        var chain2 = [
            function() { 
                console.log("step4ba");
                fs.stat("f1.js",chain2.shift());
            },
            function(err, stats) { 
                console.log("step4bb");
                fs.stat("f1ab.js",next);
            },
        ];
        chain2.shift()();
    },
    function(err, stats) {
        if ( --fork2 )
            return;
        console.log("done");
    },
];
chain.shift()();

为此，我非常喜欢async.js。

该问题通过瀑布命令解决：

瀑布（任务，[回调]）

连续运行一系列函数，每个函数将其结果传递给数组中的下一个。但是，如果任何函数将错误传递给回调，则不会执行下一个函数，并且会立即调用带有错误的主回调。

参数

任务 - 要运行的函数数组，每个函数都传递一个回调（err，result1，result2，...），它必须在完成时调用。第一个参数是一个错误（可以为空），任何进一步的参数都将作为参数传递给下一个任务。callback(err, [results]) - 所有函数完成后运行的可选回调。这将传递上一个任务回调的结果。

例子

async.waterfall([
    function(callback){
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback){
        callback(null, 'three');
    },
    function(arg1, callback){
        // arg1 now equals 'three'
        callback(null, 'done');
    }
], function (err, result) {
    // result now equals 'done'    
});

至于 req,res 变量，它们将在与包含整个 async.waterfall 调用的 function(req,res){} 相同的范围内共享。

不仅如此，async 非常干净。我的意思是我改变了很多这样的情况：

function(o,cb){
    function2(o,function(err, resp){
        cb(err,resp);
    })
}

首先：

function(o,cb){
    function2(o,cb);
}

然后到这个：

function2(o,cb);

然后到这个：

async.waterfall([function2,function3,function4],optionalcb)

它还允许从 util.js 非常快地调用许多为异步准备的预制函数。只要把你想做的事情串联起来，确保 o,cb 被普遍处理。这大大加快了整个编码过程。