Arrays 嵌套在async.eachSeries循环中的async.series终止提前发送POST响应

我在POST调用的接收端，该调用包含一个对象数组（requestArray）。在回复帖子之前，我需要按顺序通过一系列函数传递数组的对象。我选择了异步库来帮助我完成这项任务，但是我很难控制代码的执行流

我使用一个全局数组来存储每个函数的结果（responseArray）。有些函数依赖于先前函数的结果。我不想使用async.瀑布（），因为1。我必须重写我的代码和2。我可能会遇到相同的早期循环终止问题。下面是我的代码

app.post('/test', function(req, res) {
  var importArray = req.body;
  var iteration = 0;

  async.eachSeries(importArray, function(data, callback) {
    var index = importArray.indexOf(data);
    var element  = data.element;
    exportArray[index] = [];

    async.series([
      function(callback) {
        process1(data, index, callback);
      },
      function(callback) {
        process2(element, index, callback);
      },
      function(callback) {
        process3(element, index, callback);
      }],
      function(err, results) {  
        var str = {};
        results.forEach(function(result) {
          if (result) {
              str += result + ',';
          }
        });
        //callback();       // callback here = synchronous execution.
        if (index === req.body.length - 1) {
          res.send(exportArray);
        }
      });
      console.log('async.eachSeries() callback iteration # = ' + iteration);
      iteration++;
      callback();           // callback here = asynchronous execution.
  }, function(err){
      if( err ) {
        console.log('Error');
      } else {
        console.log('All data has been processes successfully.');
      }
  });
});

---

async.series（）中的每个函数都返回回调（null，result）。process1（）返回其回调后，async.eachSeries（）会跳到前面的下一个数组项，这非常理想。但是，async.eachSeries（）会在返回所有async.series（）结果之前执行POST响应。如何修改代码，使async.eachSeries（）在从process1-3返回所有importArray结果（exportArray）后完成执行，然后再发送POST响应？

为了便于遵循代码的异步性质，我建议稍微重命名回调。还要等待每个系列完成移动

res.send

到

eachSeries

最后一次回调，传入

结果

这是更新后的代码

app.post('/test', function(req, res) {
  var importArray = req.body;
  var iteration = 0;

  async.eachSeries(importArray, function(data, next) {
    var index = importArray.indexOf(data);
    var element  = data.element;
    exportArray[index] = [];

    async.series([
      function(cb) {
        process1(data, index, cb);
      },
      function(cb) {
        process2(element, index, cb);
      },
      function(cb) {
        process3(element, index, cb);
      }],

      function(err, results) {  
        var str = {};
        results.forEach(function(result) {
          if (result) {
              str += result + ',';
          }
        });

        console.log('async.eachSeries() callback iteration # = ' + iteration);
        iteration++;
        next(null, results);      
      });     

  }, function(err, results){
      if(err) {
        return console.log('Error');
      } 

      res.send(exportArray);
      console.log('All data has been processes successfully.');
  });
});

在@Bulkan和Tinking的帮助下，我在我的老朋友“flag”的帮助下得到了异步运行的代码。代码如下：

app.post('/test', function(req, res) {
  var importArr = req.body;
  var iteration = 0;
  var flag      = false;

  async.eachSeries(importArr, function(data, cb) {
    var index        = importArr.indexOf(data);
    var element      = data.element;
    exportArr[index] = [];

    async.series([
      function(cb) {
        process1(data, index, cb);
      },
      function(cb) {
        process2(element, index, cb);
      },
      function(cb) {
        process3(element, index, cb);
      }],

      function(err, results) {  
        var str = {};
        results.forEach(function(result) {
          if (result) {
              str += result + ',';
          }
        });
        iteration++;
        if (iteration === req.body.length) {
          flag = true;
          res.send(exportArr);
        } 
      });
      console.log('async.eachSeries() callback iteration # = ' + iteration);

      if (iteration < req.body.length) {
        cb();
      } else if (flag)  {
        cb();
      }
  }, function(err){
      if (err) {
        console.log('Error');
      } else {
        console.log('All data has been processes successfully.');
      }
  });
});

app.post（'/test'，函数（req，res）{
var importArr=请求主体；
var迭代=0；
var标志=假；
eachSeries（导入器、函数（数据、cb）{
var指数=进口指数（数据）；
var元素=data.element；
exportArr[index]=[]；
异步系列([
功能（cb）{
过程1（数据、索引、cb）；
},
功能（cb）{
过程2（元素、索引、cb）；
},
功能（cb）{
过程3（元素、索引、cb）；
}],
函数（错误，结果）{
var-str={}；
results.forEach（函数（结果）{
如果（结果）{
str+=结果+'，'；
}
});
迭代++；
if（迭代===req.body.length）{
flag=true；
res.send（exportArr）；
} 
});
log（'async.eachSeries（）回调迭代#='+迭代）；
if（迭代<所需正文长度）{
cb（）；
}else if（标志）{
cb（）；
}
}，函数（err）{
如果（错误）{
console.log（'Error'）；
}否则{
log（'所有数据已成功处理'）；
}
});
});
感谢您的修改，伯肯
next（null，results）
正在抛出错误，因为
results
不在范围内。另外，我应该有2个
res.send（exportArray）
语句吗？我能够实现您的更改，并且它工作正常。但是，它确实是同步运行的。我正在复制我必须异步运行的代码。由于年龄大了一点，我意识到早期
async的问题。eachSeries（）
循环终止是由于我错误地在
async.series（）
方法末尾插入异步方法
results.forEach（）
。我不应该使用像for（）循环那样的同步方法，而应该使用
results.forEach（）
。