嵌套节点 async.eachSeries [英] Nesting node async.eachSeries
本文介绍了嵌套节点 async.eachSeries的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！
问题描述
与异步模块斗争了半天，但在嵌套几个级别时无法使其正常工作.
所以这没问题:
<前>var async = require('async')var myarr = ["外层-A","外层-B"];var myarr2 = ["内部 - A", "内部 - B"];varinnerComplete = true;async.eachSeries(myarr, function( item, outerCallback) {console.log('处理项目' + 项目);异步系列([功能(回调){takeTime(2000，项目，回调)},功能(回调){takeTime(1000，项目，回调)},功能(回调){外回调()；}], 函数(错误){console.log("---外部序列---")})}, 函数(错误){console.log("---外循环---")});函数 takeTime(ms, msg, 回调) {console.log("从" + msg 开始" + ms + " ms 任务);设置超时(函数(){console.log("Finished " + ms + " ms task from " + msg);打回来();}， 多发性硬化症);}它按顺序很好地输出所有内容，如下所示:
<前>加工项目外-A从外部开始 2000 毫秒任务 - A完成来自外部的 2000 毫秒任务 - A从外部开始 1000 毫秒任务 - A完成了来自外部的 1000 毫秒任务 - A加工项目外-B从外部开始 2000 毫秒任务 - B完成了来自外部的 2000 毫秒任务 - B从外部开始 1000 毫秒任务 - B完成了来自外部的 1000 毫秒任务 - B---外环---但是当我尝试像这样将另一个 eachSeries 循环嵌套到其中时:
<前>var async = require('async')var myarr = ["外层-A","外层-B"];var myarr2 = ["内部 - A", "内部 - B"];varinnerComplete = true;async.eachSeries(myarr, function( item, outerCallback) {console.log('处理项目' + 项目);异步系列([功能(回调){takeTime(2000，项目，回调)},功能(回调){takeTime(1000，项目，回调)},功能(回调){async.eachSeries(myarr2, function( item2, outerCallback2) {console.log('处理项目' + item2);异步系列([功能(回调2){takeTime(2000, item2, callback2)},功能(回调2){takeTime(1000, item2, callback2)}], 函数(错误){console.log('---内部序列---')})}, 函数(错误){console.log("---内循环---")});外回调()；}], 函数(错误){console.log("---外部序列---")})}, 函数(错误){console.log("---外循环---")});函数 takeTime(ms, msg, 回调) {console.log("从" + msg 开始" + ms + " ms 任务);设置超时(函数(){console.log("Finished " + ms + " ms task from " + msg);打回来();}， 多发性硬化症);}进入第二个 eachSeries 循环时会丢失执行顺序，如下所示:
<前>加工项目外-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，你不是在调用 callback，你'立即重新调用 outerCallback.
已修复:
async.eachSeries(myarr, function( item, outerCallback) {,----------------------------------------'|console.log('处理项目' + 项目);|异步系列([|功能(回调){|`--------------，|takeTime(2000，项目，回调)|},|功能(回调){|`--------------，|takeTime(1000，项目，回调)|},|功能(回调){|,-----------'||async.eachSeries(myarr2, function( item2, outerCallback2) {||,------------------------------------------------------------|||console.log('处理项目' + item2);|||异步系列([|||功能(回调2){|||takeTime(2000, item2, callback2)|||},|||功能(回调2){|||takeTime(1000, item2, callback2)|||}|||], 函数(错误){|||console.log('---内部序列---')||`--->外层回调2(错误)；//<<<||})||}, 函数(错误){||console.log("---内循环---");|`--->回调(错误)；//<<<|});|}|], 函数(错误){|console.log("---外部序列---")`--->外回调(错误)；//<<<})}, 函数(错误){console.log("---外循环---")console.log("一切都完成了");});Been fighting with async module for half a day but can't get it to work properly when nesting few levels.
So this works ok:
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);
}
And it outputs everything nicely in sequence like this:
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---
But when I try to nest another eachSeries loop into it like this:
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);
}
It loses the execution order when entering the second eachSeries loop like this:
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---
I also tried out waterfall, mapSeries etc, but with same or otherwise messed up sequence of execution. Am I doing something wrong or doesn't the async module support such nesting?
解决方案
You're not calling the outerCallback2, you're not calling the callback, and you're calling the outerCallback immediately.
Fixed:
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的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
查看全文
