Node.js 是否可以在nodejs异步(瀑布、系列等)中构建动态任务列表

Node.js 是否可以在nodejs异步(瀑布、系列等)中构建动态任务列表,node.js,mongodb,asynchronous,async.js,Node.js,Mongodb,Asynchronous,Async.js,我从mongo中包含节点和边缘数据的一些集合中提取信息。首先我必须得到节点,这样我才能抓住它的边。一旦我有了一个边列表,我就会返回并抓取更多的节点(等等,基于深度值)。下面的代码是一个松散的示例,说明了我如何尝试使用async.瀑布和任务列表 最初,我只有一个任务,但一旦我进行了第一次查询,我就添加到任务数组中。不幸的是,这似乎没有注册到async,并且它不会继续处理我添加的任务 有更好的方法吗 var async = require('async') var mongoose = requir

我从mongo中包含节点和边缘数据的一些集合中提取信息。首先我必须得到节点,这样我才能抓住它的边。一旦我有了一个边列表,我就会返回并抓取更多的节点(等等,基于深度值)。下面的代码是一个松散的示例,说明了我如何尝试使用async.瀑布和任务列表

最初,我只有一个任务,但一旦我进行了第一次查询,我就添加到任务数组中。不幸的是,这似乎没有注册到async,并且它不会继续处理我添加的任务

有更好的方法吗

var async = require('async')
var mongoose = require('mongoose')
var _ = requrie('underscore')

var Client = this.Mongo.connect(/*path to mongo*/)
var Node = mongoose.Schema({
    id : String,
    graph_id : String
})
var Edge = mongoose.Schema({
    id : String,
    source_id : String,
    destination_id : String
})
var Nodes = Client.model('myNode', Node)
var Edges = Client.model('myEdge', Edge)
var funcs = []
var round = 1
var depth = 2

var query = {
    node : {
        id : '12345'
    },
    edge : {
        id : '12345'   
    }
}

var addTask = function(Nodes, Edges, query, round, depth) {
    return function(callback) {
    queryData(Nodes, Edges, query, function(err, node_list) {
        if(depth > round) {
             round++
             function_array.push(addTask(Nodes, Edges, query, round, depth))
        }
    })
}
}

var queryData = function(Nodes, Edges, query, cb) {
async.waterfall([
    function(callback) {
        Nodes.find(query.node, function(err, nodes) {
            var node_keys = _.map(nodes, function(node) {
                 return node.id  
            })
            callback(null, nodes, node_keys)  
        })
    },
    function(nodes, node_keys, callback) {
        query.edge.$or = [ {'source_id' : {$in:node_keys}}, {'destination_id' : {$in:node_keys}} ]
        Edges.find(query.edge, function(err, edges) {
            var edge_keys = _.map(edges, function(edge) {
                if(edge['_doc']['source_id'] != query.node.id) {
                     return edge['_doc']['source_id']
                } else {
                     return edge['_doc']['destination_id']
                }
                callback(null, nodes, edges, node_keys, edge_keys)
            })
        })
    }
], function(err, nodes, edges, node_keys, edge_keys) {
    // update the results object then...
    cb(null, _.uniq(edge_keys)
 })
}

var function_array = []
function_array.push(addTask(Nodes, Edges, query, round, depth))

async.waterfall(function_array, function(err) {
    Client.disconnect()
    //this should have run more than just the initial task but does not
})    
---------------------更新---------------------------

因此,在尝试通过添加后续函数使Async瀑布或系列实现这一点后,我决定切换到使用Async.while,现在我对该解决方案感到满意

function GraphObject() {
  this.function_array = []
}

GraphObject.prototype.doStuff = function() {
  this.function_array.push(this.buildFunction(100))
  this.runTasks(function(err) {
     console.log('done with all tasks')
  }
}

GraphObject.prototype.buildFunction = function(times) {
  return function(cb) {
    if(times != 0) {
      this.function_array.push(this.buildFunction(times - 1))
    }
    cb(null)
  }
}

GraphObject.prototype.runTasks = function(cb) {
  var tasks_run = 0
  async.whilst(
    function(){
      return this.function_array.length > 0
    }.bind(this),
    function(callback) {
      var func = this.function_array.shift()
      func.call(this, function(err) { 
        tasks_run++
        callback(err) 
      })
    }.bind(this),
    function(err) {
      console.log('runTasks ran '+tasks_run+' tasks')
      if(err) {
        cb(500)
      }
      cb(null)
    }.bind(this)
  )
}

如果函数数组中的任务不是数组中的最后一个任务,则只能将新任务添加到数组中

在您的例子中,函数数组只包含一个任务。该任务本身无法添加其他任务,因为它是最后一个任务

解决方案是在阵列中有2个任务。引导流程的startTask和更像是虚拟任务的finalTask。那么,

function_array=[startTask,finalTask]

然后startTask将添加taskA,taskB将添加TaskC,最终

function_array=[startTask、taskA、taskB、taskC、finalTask]

下面的示例代码演示了这些概念

var async=require('async');
var max=6;
var nodeTask=函数(任务ID、值、回调){
var r=Math.floor(Math.random()*20)+1;
console.log(“来自节点任务%d:%d”,任务ID,r);
//添加边缘任务
如果(任务ID<最大值){
功能_阵列拼接(功能_阵列长度-1,0,edgeTask);
}
回调(null,taskId+1,value+r);
};
var edgeTask=函数(任务ID、值、回调){
var r=Math.floor(Math.random()*20)+1;
console.log(“来自边缘任务%d:%d”,任务ID,r);
//添加节点任务
如果(任务ID<最大值){
函数数组拼接(函数数组长度-1,0,节点任务);
}
回调(null,taskId+1,value+r);
};
var startTask=函数(回调){
函数数组拼接(函数数组长度-1,0,节点任务);
回调(null,1,0);
};
var finalTask=函数(任务ID、值、回调){
回调(null,value);
};
var函数_数组=[startTask,finalTask];
瀑布(函数数组,函数(错误,结果){
控制台日志(“总和为”,结果);
});

这正是解决方案开尔文谢谢!异步API中是否有一节描述了任务列表中“最终”任务与其他任务的区别?如果在API文档中没有,而是在[source]()中,那么在解决方案中链接它可能会有所帮助。实际上,我做了一个预感,编写了一些示例代码进行检查,然后去检查源代码。感兴趣的源代码行在490到499之间。在实现“final function”修复后,遇到了奇怪的行为。现在,async.瀑布结果回调被多次触发。我们将研究源代码,但这毫无意义。您的任务是否调用了正确的回调?使用嵌套,很容易调用错误的回调。另外,使用异步瀑布可能不是最好的选择。获取节点并获取其边缘后,是否可以使用async#each来处理边缘任务?是的,这是我的问题。我打错电话了。