nodejs 同步循环(使用async的eachSeries和waterfall,解决异步循环问题)

记录nodejs实际使用问题。

需求描述:

使用nodejs开发后台,对同一个表的同一个字段会有多次循环连续的查询和修改操作。

//data 是个数组集合
data.foreach(function (item) {
    //1.查询a表的content字段
    //2.修改a表的content字段
})

开发中出现的问题:最开始只是使用了waterfall来控制查询和更新操作保证是顺序执行的。外层的循环用的普通for循环和foreach循环,但是for循环和foreach在node中是异步的执行的,并不能保证在每次的循环中都是先执行查询,再更新数据操作后执行下一次循环。所以采用了async模块的eachSeries(coll,iteratee,callback)保证循环的顺序执行。

async.eachSeries(coll,iteratee,callback)

coll:可以是一个数组或一个对象(用来遍历)。
iteratee:是每次遍历执行的函数。
callback:是回调函数,当遍历中出错会立刻执行回调函数并返回错误信息,若没有发生错误则会等遍历结束后将正确的结果返回。

至于waterfall就不赘述了,使用node开发的估计都避免不了它。这里主要是使用eachSeries使循环顺序执行,保证了内部sql的执行顺序。

相关的主要代码:

function deleteChp(chpId, code,pageId,contentDelId, callBack) {
    Async.waterfall(
        [
            function (cb) {
                let pageIds = "select a.`page_id` as pageId,a.`content_id` as contentId from `m_chapter` a where a.ch_id = ? Or a.parent_code like ? and a.del = ? ";
                let paramsPg = [chpId,code + '%',0];
                query.exec(pageIds,paramsPg,function (err,dataPageIds) {
                    if (err){
                        log.error(err);
                        callBack(err);
                    }else {
                        cb(null,dataPageIds);
                    }
                });
            },
            //这块是控制同步循环的部分,也就是本篇内容主要记录的问题
            function (dataPageIds,cb) {
                let count = 0;
                let len = dataPageIds.length;
                if (len > 0){
                    Async.eachSeries(dataPageIds,function (item, cbx) {//使用eachSeries控制顺序循环
                        let params = [];
                        let pageId = item.pageId;
                        let contentId = item.contentId;
                        Async.waterfall([                              //使用waterfall来控制查询和更新数据的操作顺序执行
                            function (cb2) {
                                let sql = "select a.modify_content as content from s_pages a where a.sp_id = ? and a.del = ?";
                                params = [pageId,0];
                                query.exec(sql,params,function (err,data) {
                                    if (err){
                                        log.error(err);
                                        callBack(err);
                                    }else {
                                        cb2(null,data);
                                    }
                                });
                            },
                            function (data,cb2) {
                                let results = data;
                                if (results.length > 0){
                                    let content = deleteSmark(results[0],contentId);
                                    let pm = [];
                                    //修改smark内容
                                    let  str = " UPDATE `s_pages` SET modify_content = ? WHERE sp_id = ? and del = ? ";
                                    pm.push(content);
                                    pm.push(pageId);
                                    pm.push(0);
                                    query.exec(str,pm,function (err) {
                                        if (err){
                                            log.error(err);
                                            callBack(err);
                                        }
                                        count++;
                                        if (count == dataPageIds.length){
                                            cb2(null,1);
                                        } else {
                                            cbx(null);
                                        }

                                    });
                                }else {
                                    cb2(null,0)
                                }
                            }
                        ],function (err,res) {
                            if (err){
                                log.error(err);
                                callBack(err);
                            }
                            cb(null,res);
                        });
                    });
                }else {
                    cb(null,0);
                }
            },
            function (datas,cb) {
                let str, queryParams;
                str = " UPDATE `m_chapter` mkp SET del= ? WHERE mkp.ch_id = ? Or mkp.parent_code like ? ";
                queryParams = [1, chpId, code + '%'];
                query.exec(str,queryParams,function (err) {
                    if (err){
                        log.error(err);
                        callBack(err);
                    }
                    cb(null, 2);
                });
            }
        ],function (err) {
            if (err){
                log.error(err);
                callBack(err);
            }
            callBack(0);
        }
    );
}

我相信慢慢一点点的进步,一定会量变到质变,凡事你不理解的,都是你的认知没有达到一定的水平。

<think>好的,我现在需要帮助用户解决在Node.js中实现异步循环问题。首先,用户提到的“异步循环”可能指的是在循环中处理异步操作,比如API调用、文件读写等,同时控制并发量,避免资源耗尽。根据用户提供的引用,特别是引用[1][5],Node.js的异步处理涉及事件循环任务队列,需要合理管理异步函数的执行次数。 用户可能需要一个具体的示例,所以我应该考虑给出几种常见的实现方式。比如使用async/await配合Promise,或者使用第三方库如async.js。引用[1]中提到在循环中控制异步函数的执行次数,这可能涉及并发控制,比如限制同时执行的异步任务数量。 另外,用户提供的引用[5]提到Node.js的宏任务队列有多个阶段,这可能影响异步任务的执行顺序。不过用户的问题更侧重于如何在循环中执行异步任务,而不是事件循环本身的结构。因此,重点应放在代码实现上。 我需要确保示例代码正确使用异步模式,比如async函数await,以及可能的并发控制方法,如Promise.all延迟执行。同时,要注意避免阻塞事件循环,这在引用[4]中也有提到。可能还需要解释每个示例的工作原理,帮助用户理解。 用户可能还关心错误处理性能优化,所以在示例中加入错误处理机制是有必要的。此外,引用[3]提到事件循环的阶段,虽然示例可能不直接涉及,但了解这些阶段有助于编写更高效的代码,比如避免长时间运行的同步任务阻塞事件循环。 总结一下,我需要提供几种实现异步循环的方法,解释其机制,并确保代码符合Node.js的最佳实践,比如非阻塞I/O合理的并发控制。同时,根据用户的引用内容,强调事件循环的管理异步任务的控制,确保回答结构清晰,步骤明确。</think>在Node.js中实现异步循环需要结合事件循环机制异步控制技术。以下是几种典型实现方式及示例: ### 方法一:基于async/await的基本实现 ```javascript async function asyncLoop(arr) { for (const item of arr) { await new Promise(resolve => { setTimeout(() => { console.log(`处理元素:${item}`); resolve(); }, 1000); }); } } asyncLoop([1, 2, 3, 4]).then(() => console.log("循环结束")); ``` **特点**:顺序执行异步操作,每个操作完成后才执行下一个。适用于需要严格顺序的场景[^1][^4]。 ### 方法二:并行执行控制(Promise.all) ```javascript async function parallelLoop(arr, concurrency = 2) { const batches = []; for (let i = 0; i < arr.length; i += concurrency) { batches.push(arr.slice(i, i + concurrency)); } for (const batch of batches) { await Promise.all(batch.map(async item => { await new Promise(resolve => setTimeout(resolve, 1000)); console.log(`并行处理:${item}`); })); } } parallelLoop([1,2,3,4,5]); ``` **特点**:通过分批次执行实现并发控制,适用于I/O密集型任务[^2][^5]。 ### 方法三:队列动态控制 ```javascript class AsyncQueue { constructor(concurrency = 2) { this.queue = []; this.active = 0; this.concurrency = concurrency; } add(task) { this.queue.push(task); this.next(); } next() { while (this.active < this.concurrency && this.queue.length) { const task = this.queue.shift(); this.active++; task().finally(() => { this.active--; this.next(); }); } } } const queue = new AsyncQueue(3); [1,2,3,4,5].forEach(item => { queue.add(async () => { await new Promise(r => setTimeout(r, 1000)); console.log(`队列处理:${item}`); }); }); ``` **特点**:动态任务队列管理,实时控制并发量,适合流式数据处理[^1][^4]。 ### 方法四:使用async库实现 ```javascript const async = require('async'); async.eachLimit([1,2,3,4,5], 2, (item, callback) => { setTimeout(() => { console.log(`async处理:${item}`); callback(); }, 1000); }, err => { console.log('全部完成'); }); ``` **特点**:通过第三方库简化代码,提供ready-to-use的并发控制方案[^5]。 ### 关键实现原理 1. **事件循环调度**:利用Node.js的libuv库处理I/O操作,通过epoll(Linux)/kqueue(MacOS)等系统调用实现高效I/O复用[^2][^5] 2. **任务优先级**:微任务(Promise)优先于宏任务(setTimeout/setImmediate)执行[^3] 3. **阶段控制**:定时器阶段 → pending callbacks → idle → poll → check → close callbacks
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

半路笙歌

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值