在 Nodejs 中管理大量回调递归

Question

在 Nodejs 中，几乎不存在阻塞 I/O 操作。这意味着几乎所有的nodejs IO代码都涉及很多回调。这适用于从数据库、文件、进程等读取和写入。典型的示例如下：

var useFile = function(filename,callback){
    posix.stat(filename).addCallback(function (stats) {
        posix.open(filename, process.O_RDONLY, 0666).addCallback(function (fd) {
            posix.read(fd, stats.size, 0).addCallback(function(contents){
                callback(contents);
            });
        });
    });
};

...

useFile("test.data",function(data){
    // use data..
});

我预计编写的代码将进行许多 IO 操作，因此我希望编写许多回调。我对使用回调非常满意，但我担心所有的递归。我是否有遇到太多递归并在某个地方破坏堆栈的危险？如果我通过数千个回调对我的键值存储进行数千次单独写入，我的程序最终会崩溃吗？

我是否误解或低估了影响？如果没有，有没有办法在仍然使用 Nodejs 的回调编码风格的同时解决这个问题？

Answer 1

您显示的代码均未使用递归。当您调用 useFile 时，它会调用 posix.stat()，该函数返回，并且 useFile 在运行完成时终止。稍后，当底层系统中对 posix.stat() 的调用完成并且结果可用时，您为此添加的回调函数将被执行。它调用 posix.open()，然后在运行完成时终止。文件成功打开后，that 的回调函数将执行，调用 posix.read()，然后终止，因为它也已运行完成。最后，当读取结果可用时，将执行最里面的函数。

重要的一点是，每个函数都会运行完成，因为对 posix.*() 函数的调用是非阻塞的：也就是说，它们会立即返回，从而导致在底层系统。因此，每个函数都会终止，稍后一个事件将导致下一个函数执行；但在任何时候都不存在任何递归。

代码的嵌套结构会给人一种这样的印象：内部的内容必须先完成，外部的内容才能到达其自己的终点。但在这种异步事件驱动编程风格中，从更深层次的 => 角度看待嵌套更有意义。发生晚于。

编辑：尝试在每个嵌套函数结束之前添加一些日志语句；这将有助于说明它们完成的顺序是从外向内。

Answer 2

相同的示例，添加了调试输出（输出见下文）：

usefile.js：

var sys = require("sys"),
  posix = require("posix");

var useFile = function(filename,callback){
    posix.stat(filename).addCallback(function (stats) {
        posix.open(filename, process.O_RDONLY, 0666).addCallback(function (fd) {
            posix.read(fd, stats.size, 0).addCallback(function(contents){
                callback(contents);
                sys.debug("useFile callback returned");
            });
            sys.debug("read returned");
        });
        sys.debug("open returned");
    });
    sys.debug("stat returned");
};

useFile("usefile.js",function(){});

输出：

DEBUG: stat returned
DEBUG: open returned
DEBUG: read returned
DEBUG: useFile callback returned

Answer 3

您可以尝试

http://github.com/creationix/do

或像我一样自行推出。现在不要介意缺少错误处理（只需忽略它）；）

var sys = require('sys');

var Simplifier = exports.Simplifier = function() {}

Simplifier.prototype.execute = function(context, functions, finalFunction) {
  this.functions = functions;
  this.results = {};
  this.finalFunction = finalFunction;
  this.totalNumberOfCallbacks = 0
  this.context = context;
  var self = this;

  functions.forEach(function(f) {
    f(function() {
      self.totalNumberOfCallbacks = self.totalNumberOfCallbacks + 1;
      self.results[f] = Array.prototype.slice.call(arguments, 0);     
      if(self.totalNumberOfCallbacks >= self.functions.length) {
        // Order the results by the calling order of the functions
        var finalResults = [];
        self.functions.forEach(function(f) {
          finalResults.push(self.results[f][0]);
        })
        // Call the final function passing back all the collected results in the right order 
        finalFunction.apply(self.context, finalResults);
      }
    });
  });
}

以及一个使用它的简单示例

// Execute 
new simplifier.Simplifier().execute(
  // Context of execution
  self,  
  // Array of processes to execute before doing final handling
  [function(callback) {
      db.collection('githubusers', function(err, collection) {
        collection.find({}, {limit:30}, function(err, cursor) {
          cursor.toArray(function(err, users) { callback(users); })
        });
      });      
    },

    function(callback) {
      db.collection('githubprojects', function(err, collection) {
        collection.find({}, {limit:45, sort:[['watchers', -1]]}, function(err, cursor) {
          cursor.toArray(function(err, projects) { callback(projects); })
        });
      });              
    }
  ],  
  // Handle the final result
  function(users, projects) {
    // Do something when ready
  }
);

Answer 4

你的东西没问题。我在 Express 中进行递归调用以遵循 HTTP 重定向，但您所做的是“遍历”而不是递归

Answer 5

另请查看“step”(http://github.com/creationix/step) 或github 上的“flow-js”。这使您可以以更自然的风格编写回调流。这也将表明没有发生递归。

Answer 6

与任何 JavaScript 一样，可以使用 Node.js 进行递归调用。如果您确实遇到了递归深度问题（正如 NickFitz 指出的那样，您似乎没有遇到这种危险），您通常可以重写代码以使用间隔计时器。