Question

我想处理一系列数据，其中每个数据的输出可用作其他数据的输入。

例如：

    var batch = [
        {"id":"a1","depends":[],"data":{"some":"data a1"}},
        {"id":"b1","depends":["a1"],"data":{"some":"data b1"}},
        {"id":"b2","depends":["a1"],"data":{"some":"data b2"}},
        {"id":"c1","depends":["b1","b2"],"data":{"some":"data c1"}},
        {"id":"x1","depends":[],"data":{"some":"data x1"}},
    ];

这意味着，a1完成后，其输出将发送到b1和b2; 当这些完成时，它们的输出都将被发送到c1（仅在它们完成时）。 x1可以与所有a1，b1，b2和c1并行执行; 并且b1可以与b2并行执行，因为它们之间没有定义depends。

完成c1和x1，并完成所有5个后，应返回所有五个的输出。

我们假设没有定义循环依赖，因此是有向无环图（DAG）

我想知道如何使用Q来实现这一点，因为：

所有数据处理都是异步的，因此我需要使用回调，延迟和承诺; 我更喜欢后者
Promise可以加倍作为在图表中定义边缘的便捷方式

然而，我未能将这个概念放在概念阶段

var doPromises = {};

var doData = function(data, dependsResultsHash, callback) {
  //Not real processing, simply echoes input after a delay for async simulation purposes
  var out = {
    echo: {
      data: data,
      dependsResultsHash: dependsResultsHash
    }
  };
  setTimeout(function() {
    callback(out);
  }, 1000);
};

var doLine = function(id, depIds, data) {
  var deferred = Q.defer;
  var dependsPromises = [];
  for (var i = 0; i < depIds.length; ++i) {
    var depId = depIds[i];
    dependPromise = doPromises[depId];
    dependsPromises.push(dependPromise);
  }
  Q.all(dependsPromises).then(function(dependsResults) {
    var dependsResultsHash = {};
    for (var i = 0; i < depIds.length; ++i) {
      var depId = depIds[i];
      var depResult = dependsResults[i];
      dependsResultsHash[depId] = depResult;
    }
    doData(data, dependsResultsHash, function(result) {
      deferred.resolve(result);
    });
  });
  return deferred.promise;
}

var doBatch = function(batch) {
  var linePromises = [];
  for (var i = 0; i < batch.length; ++i) {
    var line = batch[i];
    var linePromise = doLine(line.id, line.depends, line.data);
    linePromises.push(linePromise);
    doPromises[line.id] = linePromise;
  }
  Q.all(linePromises).then(function(lineResults) {
    console.log(lineResults);
    deferred.resolve(lineResults);
  });
};

doBatch(batch);

（请注意，此代码未经测试，我认为它不起作用，只是为了说明我的问题所需的要点。）

我想知道：

我这样做了吗？我完全忽略了Q库的要点。还是延期和承诺？

我主要担心的是doData功能：

-- Is the way that I have selected the promises of the lines depended upon from the global list of promises `doPromises` ok?
-- Is the way that I have obtained the results of the lines depended upon, and inpterpreted that OK?

使用doBatch功能：

-- I have a local array for `linePromises` and an external hash for `doPromises`, and I feel that these should be combined. How can I do this correctly?

一般

-- The code above presently assumes that all `deferred`s will eventually keep their `promise`s. What if they fail or throw an exception; how do I make my code more robust in handling this?
-- I have used a closure allow acces to `doPromises` in both `doBatch` and `doLine`, and it seems a little odd here, is there a better way to do this?

Answer 1

我创建了一个执行此操作的库：

qryq是一个NodeJs库，它允许表达一系列查询并在它们之间并行，按顺序或在有向非循环图中定义它们之间的依赖关系。

Answer 2

我最近创建了一个名为dagmise的模块，我计划将其用于构建使用promises作为任务的构建系统。我最终制作了返回promises的图形函数的节点。访问节点时，将评估其中的函数，并且返回的promised将其作为节点的值。因此，即使多次访问节点，该函数也只执行一次。

我开始认为承诺应该是边缘，但现在我认为将它们放在节点上更简单。否则你最终会在图形中出现两种对象（节点/状态和边缘/承诺），这会使事情变得复杂。

Answer 3

我刚刚为此实现了自己的库：promise-dag。

由于以下原因，我对上述替代方案（dagmise，qryq）不满意：

他们实施了具体的Promise实施。 promise-dag与任何Promise实现兼容，没有任何代码依赖。
它们提供了流畅的API（链接方法）。我更喜欢面向数据的API，它更具可编程性和透明性，可以使用普通的数据结构函数（_.extend()，_.pick()，...）轻松组合计算图，以及添加自定义检测（分析/跟踪/记录/等）。

问 - 执行一系列承诺并在DAG中定义它们之间的依赖关系

3 个答案: