如何将函数调用推送到数组而不在 Node JS 中调用它们以使用 Q？

Question

我希望创建一个函数数组来动态调用，稍后将在 Q.all([]) 承诺调用中使用。

例如；

 //data is previously generated

 var promiseArray = [];
 for (var i = 0; i < data.length; i++){     
   promiseArray.push(functionCall(data[i]))
 }
 Q.all(promiseArray).then(function(){
      //Do something 
 })

在 Q.all 语句之前，如何在不调用函数的情况下推送到数组？我不想在 for 循环中调用它，因为它不会捕获任何错误并且我无法进一步处理响应。

编辑：

所以为了澄清我的问题（因为我认为我没有像我应该说的那样清楚），这里是静态数据长度为 3 的解决方案；

//data is previously generated
var data = [12432432,4324322392,433324323];

//Each function call can happen in parallel or series as its an external POST to an API
//I'm not bothered about speed for this application (as its low throughput) and can wait a few seconds for each
// response
//FunctionCall returns a promise

functionCall(data[0]).then(function(){
    //Log success / failure to mongo
});
functionCall(data[1]).then(function(){
    //Log success / failure to mongo
});
functionCall(data[2]).then(function(){
    //Log success / failure to mongo
});

//OR
functionCall(data[0]).then(function(){
    //Log success/failure to mongo
    functionCall(data[1]).then(function(){
        //Log success/failure to mongo
        functionCall(data[2]).then(function(){
            //Log success/failure to mongo
        });
    });
});

但是直到运行时我才知道数据的长度

Answer 1

如果我理解正确，您想为一组项目调用 functionCall，并在 functionCall 返回的所有承诺完成后让 Q.all 解决，无论它们是否解决或拒绝 - 如果您不关心结果（因为您的代码中似乎并不关心），只需处理您推送的承诺中的拒绝 - 即

var promiseArray = [];
for (var i = 0; i < data.length; i++) {
    promiseArray.push(functionCall(data[i]).then(function(result) {
        // log success
        return logToMongoFunction(result);
    }, function(error) {
        // log failure
        return logToMongoFunction(error);
    }).catch(function(error) {
        // catch and ignore any error thrown in either logToMongoFunction above
        return;
    }));
}
Q.all(promiseArray).then(function () {
    //Do something 
});

注意：以上可以简化为

Q.all(data.map(function (item) {
    return functionCall(item).then(function(result) {
        // log success
        return logToMongoFunction(result);
    }, function(error) {
        // log failure
        return logToMongoFunction(error);
    }).catch(function(error) {
        // catch and ignore any error thrown in either logToMongoFunction above
        return;
    });
})).then(function() {
    //Do something 
});

---

编辑后的问题表明您也可以按顺序执行操作 - 可以按顺序执行

data.reduce(function(promise, item) {
    return promise.then(function() {
        return functionCall(item).then(function(result) {
            // log success
            return logToMongoFunction(result);
        }, function(error) {
            // log failure
            return logToMongoFunction(error);
        }).catch(function(error) {
            // catch and ignore any error thrown in either logToMongoFunction above
            return;
        });
    });
}, Promise.resolve()).then(function() {
    // all done
});

您可以使用 Q 所拥有的任何东西来代替 Promise.resolve()，作为创建已解决承诺的等价物

logToMongoFunction 将登录到 mongo 并需要返回一个承诺如果您需要等待它完成，然后再处理下一个数据项。如果您不需要等待 mongo 日志记录完成，则该函数无需返回承诺

Answer 2

我建议为此使用 Promise.mapSeries 或异步库，因为它很容易捕获错误。如果您在回调中有数据库调用，那么使用 for 循环进行循环的另一件事似乎不是好方法，因为这可能会刷新对数据库的调用，并且 node.js 可能存在内存问题，或者 node.js 将无法处理任何其他问题请求，因为它将忙于处理 for 循环中的请求。所以串行运行循环或一次限制并行执行的数量总是好的。

请看下面的例子

  This will run Array serially one at a time when 1st one completes execution next will be called

  async.eachOfSeries(data, function(dataInstance, key, next) {
    functionCall(dataInstance).then(function(){
        next();
    }).catch(funtion(err){
        next(err);
    })
  }, function() {
        //iteration completed
  });

或

 async.eachOfSeries(data, function(dataInstance, key, next) {
    functionCall(dataInstance, function(err , result){
        if(err)
          {
            console.log(err);
            next(err);
          }
          else
            next();
    });
  }, function() {
        //iteration completed
  });