Javascript 嵌套节点async.eachSeries

与异步模块斗争了半天，但在嵌套几个级别时无法使其正常工作

这样就行了：

var async = require('async') var myarr = ["Outer - A", "Outer - B"]; var myarr2 = ["Inner - A", "Inner - B"]; var innerComplete = true; async.eachSeries(myarr, function( item, outerCallback) { console.log('Processing item ' + item); async.series([ function(callback) { takeTime(2000, item, callback) }, function(callback) { takeTime(1000, item, callback) }, function(callback) { outerCallback(); } ], function(err) { console.log("---OUTER SEQUENCE---") }) }, function(err){ console.log("---OUTER LOOP---") }); function takeTime(ms, msg, callback) { console.log("Starting " + ms + " ms task from " + msg); setTimeout( function() { console.log("Finished " + ms + " ms task from " + msg); callback(); }, ms); } var async=require（'async'） var myarr=[“外部-A”，“外部-B”]； var myarr2=[“内部-A”，“内部-B”]； var innerComplete=true； eachSeries（myarr，函数（item，outerCallback）{ console.log（'处理项'+项）； 异步系列([ 函数（回调）{ takeTime（2000，项目，回调） }, 函数（回调）{ takeTime（1000，项目，回调） }, 函数（回调）{ outerCallback（）； } ]，函数（err）{ console.log（“--OUTER SEQUENCE--”） }) }，函数（err）{ console.log（“--OUTER-LOOP--”） }); 函数执行时间（毫秒、消息、回调）{ log（“从“+msg”启动“+ms+”ms任务）； setTimeout（函数（）{ console.log（“已完成”+ms+“来自”+msg的ms任务”）； 回调（）； }，ms）； } 它按如下顺序很好地输出所有内容：

Processing item Outer - A Starting 2000 ms task from Outer - A Finished 2000 ms task from Outer - A Starting 1000 ms task from Outer - A Finished 1000 ms task from Outer - A Processing item Outer - B Starting 2000 ms task from Outer - B Finished 2000 ms task from Outer - B Starting 1000 ms task from Outer - B Finished 1000 ms task from Outer - B ---OUTER LOOP--- var async = require('async') var myarr = ["Outer - A", "Outer - B"]; var myarr2 = ["Inner - A", "Inner - B"]; var innerComplete = true; async.eachSeries(myarr, function( item, outerCallback) { console.log('Processing item ' + item); async.series([ function(callback) { takeTime(2000, item, callback) }, function(callback) { takeTime(1000, item, callback) }, function(callback) { async.eachSeries(myarr2, function( item2, outerCallback2) { console.log('Processing item ' + item2); async.series([ function(callback2) { takeTime(2000, item2, callback2) }, function(callback2) { takeTime(1000, item2, callback2) } ], function(err) { console.log('---INNER SEQUENCE---') }) }, function(err){ console.log("---INNER LOOP---") }); outerCallback(); } ], function(err) { console.log("---OUTER SEQUENCE---") }) }, function(err){ console.log("---OUTER LOOP---") }); function takeTime(ms, msg, callback) { console.log("Starting " + ms + " ms task from " + msg); setTimeout( function() { console.log("Finished " + ms + " ms task from " + msg); callback(); }, ms); } Processing item Outer - A Starting 2000 ms task from Outer - A Finished 2000 ms task from Outer - A Starting 1000 ms task from Outer - A Finished 1000 ms task from Outer - A Processing item Inner - A Starting 2000 ms task from Inner - A Processing item Outer - B Starting 2000 ms task from Outer - B Finished 2000 ms task from Inner - A Starting 1000 ms task from Inner - A Finished 2000 ms task from Outer - B Starting 1000 ms task from Outer - B Finished 1000 ms task from Inner - A ---INNER SEQUENCE--- Finished 1000 ms task from Outer - B Processing item Inner - A Starting 2000 ms task from Inner - A ---OUTER LOOP--- Finished 2000 ms task from Inner - A Starting 1000 ms task from Inner - A Finished 1000 ms task from Inner - A ---INNER SEQUENCE--- 处理项目外部-A 从外部启动2000毫秒任务-A 从外部完成2000毫秒任务-A 从外部启动1000毫秒任务-A 从外部完成1000毫秒任务-A 处理项目外部-B 从外部启动2000毫秒任务-B 从外部完成2000毫秒任务-B 从外部启动1000毫秒任务-B 从外部完成1000毫秒任务-B ---外环--- 但当我尝试将另一个eachSeries循环嵌套到其中时，如下所示：

Processing item Outer - A Starting 2000 ms task from Outer - A Finished 2000 ms task from Outer - A Starting 1000 ms task from Outer - A Finished 1000 ms task from Outer - A Processing item Outer - B Starting 2000 ms task from Outer - B Finished 2000 ms task from Outer - B Starting 1000 ms task from Outer - B Finished 1000 ms task from Outer - B ---OUTER LOOP--- var async = require('async') var myarr = ["Outer - A", "Outer - B"]; var myarr2 = ["Inner - A", "Inner - B"]; var innerComplete = true; async.eachSeries(myarr, function( item, outerCallback) { console.log('Processing item ' + item); async.series([ function(callback) { takeTime(2000, item, callback) }, function(callback) { takeTime(1000, item, callback) }, function(callback) { async.eachSeries(myarr2, function( item2, outerCallback2) { console.log('Processing item ' + item2); async.series([ function(callback2) { takeTime(2000, item2, callback2) }, function(callback2) { takeTime(1000, item2, callback2) } ], function(err) { console.log('---INNER SEQUENCE---') }) }, function(err){ console.log("---INNER LOOP---") }); outerCallback(); } ], function(err) { console.log("---OUTER SEQUENCE---") }) }, function(err){ console.log("---OUTER LOOP---") }); function takeTime(ms, msg, callback) { console.log("Starting " + ms + " ms task from " + msg); setTimeout( function() { console.log("Finished " + ms + " ms task from " + msg); callback(); }, ms); } Processing item Outer - A Starting 2000 ms task from Outer - A Finished 2000 ms task from Outer - A Starting 1000 ms task from Outer - A Finished 1000 ms task from Outer - A Processing item Inner - A Starting 2000 ms task from Inner - A Processing item Outer - B Starting 2000 ms task from Outer - B Finished 2000 ms task from Inner - A Starting 1000 ms task from Inner - A Finished 2000 ms task from Outer - B Starting 1000 ms task from Outer - B Finished 1000 ms task from Inner - A ---INNER SEQUENCE--- Finished 1000 ms task from Outer - B Processing item Inner - A Starting 2000 ms task from Inner - A ---OUTER LOOP--- Finished 2000 ms task from Inner - A Starting 1000 ms task from Inner - A Finished 1000 ms task from Inner - A ---INNER SEQUENCE--- var async=require（'async'） var myarr=[“外部-A”，“外部-B”]； var myarr2=[“内部-A”，“内部-B”]； var innerComplete=true； eachSeries（myarr，函数（item，outerCallback）{ console.log（'处理项'+项）； 异步系列([ 函数（回调）{ takeTime（2000，项目，回调） }, 函数（回调）{ takeTime（1000，项目，回调） }, 函数（回调）{ eachSeries（myarr2，函数（item2，outerCallback2）{ console.log（'处理项'+项2）； 异步系列([ 函数（回调2）{ 时间（2000年，第2项，回拨2） }, 函数（回调2）{ 花费时间（1000，项目2，回拨2） } ]，函数（err）{ console.log（'---内部序列--'） }) }，函数（err）{ console.log（“---内部循环--”） }); outerCallback（）； } ]，函数（err）{ console.log（“--OUTER SEQUENCE--”） }) }，函数（err）{ console.log（“--OUTER-LOOP--”） }); 函数执行时间（毫秒、消息、回调）{ log（“从“+msg”启动“+ms+”ms任务）； setTimeout（函数（）{ console.log（“已完成”+ms+“来自”+msg的ms任务”）； 回调（）； }，ms）； } 当进入第二个eachSeries循环时，它会丢失执行顺序，如下所示：

Processing item Outer - A Starting 2000 ms task from Outer - A Finished 2000 ms task from Outer - A Starting 1000 ms task from Outer - A Finished 1000 ms task from Outer - A Processing item Outer - B Starting 2000 ms task from Outer - B Finished 2000 ms task from Outer - B Starting 1000 ms task from Outer - B Finished 1000 ms task from Outer - B ---OUTER LOOP--- var async = require('async') var myarr = ["Outer - A", "Outer - B"]; var myarr2 = ["Inner - A", "Inner - B"]; var innerComplete = true; async.eachSeries(myarr, function( item, outerCallback) { console.log('Processing item ' + item); async.series([ function(callback) { takeTime(2000, item, callback) }, function(callback) { takeTime(1000, item, callback) }, function(callback) { async.eachSeries(myarr2, function( item2, outerCallback2) { console.log('Processing item ' + item2); async.series([ function(callback2) { takeTime(2000, item2, callback2) }, function(callback2) { takeTime(1000, item2, callback2) } ], function(err) { console.log('---INNER SEQUENCE---') }) }, function(err){ console.log("---INNER LOOP---") }); outerCallback(); } ], function(err) { console.log("---OUTER SEQUENCE---") }) }, function(err){ console.log("---OUTER LOOP---") }); function takeTime(ms, msg, callback) { console.log("Starting " + ms + " ms task from " + msg); setTimeout( function() { console.log("Finished " + ms + " ms task from " + msg); callback(); }, ms); } Processing item Outer - A Starting 2000 ms task from Outer - A Finished 2000 ms task from Outer - A Starting 1000 ms task from Outer - A Finished 1000 ms task from Outer - A Processing item Inner - A Starting 2000 ms task from Inner - A Processing item Outer - B Starting 2000 ms task from Outer - B Finished 2000 ms task from Inner - A Starting 1000 ms task from Inner - A Finished 2000 ms task from Outer - B Starting 1000 ms task from Outer - B Finished 1000 ms task from Inner - A ---INNER SEQUENCE--- Finished 1000 ms task from Outer - B Processing item Inner - A Starting 2000 ms task from Inner - A ---OUTER LOOP--- Finished 2000 ms task from Inner - A Starting 1000 ms task from Inner - A Finished 1000 ms task from Inner - A ---INNER SEQUENCE--- 处理项目外部-A 从外部启动2000毫秒任务-A 从外部完成2000毫秒任务-A 从外部启动1000毫秒任务-A 从外部完成1000毫秒任务-A 处理项目内部-A 从内部启动2000毫秒任务-A 处理项目外部-B 从外部启动2000毫秒任务-B 从内部完成2000毫秒任务-A 从内部启动1000毫秒任务-A 从外部完成2000毫秒任务-B 从外部启动1000毫秒任务-B 从内部完成1000毫秒任务-A ---内部序列--- 从外部完成1000毫秒任务-B 处理项目内部-A 从内部启动2000毫秒任务-A ---外环--- 从内部完成2000毫秒任务-A 从内部启动1000毫秒任务-A 从内部完成1000毫秒任务-A ---内部序列---

---

我还尝试了瀑布、mapSeries等，但执行顺序相同或混乱。我做错了什么，还是异步模块不支持这种嵌套？

您没有调用

outerCallback2

，没有调用

回调

，并且您正在立即调用

outerCallback

固定的：

async.eachSeries(myarr, function( item, outerCallback) {
  ,----------------------------------------'
  |  console.log('Processing item ' + item);
  |  async.series([
  |      function(callback) {
  |                 `--------------,
  |          takeTime(2000, item, callback)
  |      },
  |      function(callback) {
  |                 `--------------,
  |          takeTime(1000, item, callback)
  |      },
  |      function(callback) {
  |     ,-----------'
  |     |     async.eachSeries(myarr2, function( item2, outerCallback2) {
  |     |    ,---------------------------------------------'
  |     |    |   console.log('Processing item ' + item2);
  |     |    |   async.series([
  |     |    |      function(callback2) {
  |     |    |          takeTime(2000, item2, callback2)
  |     |    |      },
  |     |    |      function(callback2) {
  |     |    |          takeTime(1000, item2, callback2)
  |     |    |      }
  |     |    |  ], function(err) {
  |     |    |      console.log('---INNER SEQUENCE---')
  |     |    `--->  outerCallback2(err); // <<<
  |     |       })
  |     |   }, function(err){
  |     |      console.log("---INNER LOOP---");
  |     `--->  callback(err); // <<<
  |         });
  |     }
  | ], function(err) {
  |      console.log("---OUTER SEQUENCE---")
  `--->  outerCallback(err); // <<<
    })
}, function(err){
    console.log("---OUTER LOOP---")
    console.log("everything done");
});

async.eachSeries（myarr，函数（item，outerCallback）{
,----------------------------------------'
|console.log（'处理项'+项）；
|异步系列([
|函数（回调）{
|                 `--------------,
|takeTime（2000，项目，回调）
|      },
|函数（回调）{
|                 `--------------,
|takeTime（1000，项目，回调）
|      },
|函数（回调）{
|     ,-----------'
|| async.eachSeries（myarr2，函数（item2，outerCallback2）{
|     |    ,---------------------------------------------'
|| | console.log（'处理项'+项2）；
|| | async.series([
|| |函数（回调2）{
|| |花费时间（2000年，第2项，回拨2）
|     |    |      },
|| |函数（回调2）{
|| |花费时间（1000，第2项，回拨2）
|     |    |      }
|| |]，函数（err）{
|| | console.log（'---内部序列---'））
||`->outerCallback2（err）；//创造了奇迹，这是一篇很好的文章，可以更好地掌握嵌套结构中的回调。万分感谢Bergi！天哪，谢谢你的帮助，有没有更“基于函数调用”的方法来做到这一点？@timhc22：“基于函数调用”是什么意思？如果您不喜欢到处传递回调并关心返回值，那么您应该看看承诺。我仍在深入了解Node（和Javascript）的工作方式