Node.js 异步流程控制

最新推荐文章于 2024-04-25 16:16:34 发布
最新推荐文章于 2024-04-25 16:16:34 发布
阅读量597 收藏 1
点赞数
分类专栏： Node.js 文章标签： 流程控制 异步 node.js
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cckevincyh/article/details/78504038
版权

Node.js 异步流程控制

异步流程控制对象async

  • 串行无关联：async.series
  • 并行无关联：async.parallel
  • 串行有关联：waterfall
  • parallelLimit：parallelLimit函数和parallel类似，但是他多了一个参数limit
  • limit参数限制任务只能同时并发一定数量，而不是无限制并发

首先我们需要安装async模块：
这里写图片描述

这里写图片描述

我们来看看同步的情况：

function oneFun(){

    console.log("oneFun");
}


function twoFun(){
    console.log("twoFun");
}


oneFun();
twoFun();

console.log("end");

这里写图片描述

方法同步执行。

现在我们来写一个异步的例子：

function oneFun(){

    var i = 0;
    /*
    setTimeout(function(){
        console.log("oneFun");
    },1000);//1秒之后调用
    */
    setInterval(function(){
        console.log("oneFun");
        i++;
        if(i == 3){
            clearInterval(this);
        }
    },1000);//每隔1秒调用一次
}


function twoFun(){
    var j = 0;
    setInterval(function(){
        console.log("twoFun");
        j++;
        if(j == 3){
            clearInterval(this);
        }
    },1000);//每隔1秒调用一次

}


oneFun();
twoFun();

console.log("end");

这里写图片描述

我们发现两个方法交叉执行。
如果我们想要oneFun执行完在执行twoFun的话，我们需要如下改写代码：

function oneFun(){

    var i = 0;
    /*
    setTimeout(function(){
        console.log("oneFun");
    },1000);//1秒之后调用
    */
    setInterval(function(){
        console.log("oneFun");
        i++;
        if(i == 3){
            clearInterval(this);
            twoFun();//等待oneFun执行完回调
        }
    },1000);//每隔1秒调用一次
}


function twoFun(){
    var j = 0;
    setInterval(function(){
        console.log("twoFun");
        j++;
        if(j == 3){
            clearInterval(this);
        }
    },1000);//每隔1秒调用一次

}


oneFun();


console.log("end");

这里写图片描述

我们发现实现了我们想要的，但是如果我们要执行的方法很多，就需要回调中继续嵌套回调，这样看起来很乱而且难以维护。

async.series

我们接下来用async.series来改造：

var async = require('async');

function exec(){
//串行无关联
    async.series(
        {   //这里面是串行的方法
            one : function(done){
                //回调函数写在这 
                done(null,'one完毕');//done执行完之后才会执行two函数
            },
            two : function(done){
                done(null,'two完毕');
            }
        },function(err,rs){
            console.log(err);
            console.log(rs);
        }   
    )
}

exec();

console.log("end");

这里写图片描述

var async = require('async');

function exec(){
//串行无关联
    async.series(
        {   //这里面是串行的方法
            one : function(done){
                //回调函数写在这 
                done('错误','one完毕');//只要done不执行就不会执行下一个函数
            },
            two : function(done){
                done(null,'two完毕');
            }
        },function(err,rs){
            console.log(err);
            console.log(rs);
        }   
    )
}

exec();

console.log("end");

这里写图片描述
所以出现错误之后，下一个函数two就不执行了。

var async = require('async');

function exec(){
//串行无关联
    async.series(
        {   //这里面是串行的方法
            one : function(done){
                //回调函数写在这 
                var i = 0;
                /*
                setTimeout(function(){
                    console.log("oneFun");
                },1000);//1秒之后调用
                */
                setInterval(function(){
                    console.log("oneFun");
                    i++;
                    if(i == 3){
                        clearInterval(this);
                        done(null,'one完毕');
                    }
                },1000);//每隔1秒调用一次
            },
            two : function(done){
                    var j = 0;
                    setInterval(function(){
                        console.log("twoFun");
                        j++;
                        if(j == 3){
                            clearInterval(this);
                            done(null,'two完毕');
                        }
                    },1000);//每隔1秒调用一次
            }
        },function(err,rs){
            console.log(err);
            console.log(rs);
        }   
    )
}

exec();

console.log("end");

这里写图片描述
我们可以看出oneFun执行完毕之后，two才开始执行

  • series可以接受数组作为参数，需要串行处理的方法作为数组的元素。
var async = require('async');

async.series(
    [
        function (callback) {
            setTimeout(function () {
                console.log('event A occurs')
                callback(null, 'A')   // 第一个参数是异常错误，第二个参数是返回值
            }, 3000)
        },
        function (callback) {
            console.log('event B occurs');
            callback(null, 'B')
        }
    ], function (err, results) {
        // results是返回值的数组
        console.log('event ' + results[0] + results[1] + ' occurs')
    }
)
console.log("event D occurs")

这里写图片描述

  • async.series也可以接受对象作为参数，代码如下：
var async = require('async');
async.series(
    {
        A: function (callback) {
            setTimeout(function () {
                console.log('event A occurs')
                callback(null, 'A')   // 第一个参数是异常错误，第二个参数是返回值
            }, 3000)
        },
        B: function (callback) {
            console.log('event B occurs');
            callback(null, 'B')
        }
    }, function (err, results) {
        // results是所有的返回值合集，results.A获取的是A的返回值。
        console.log('event ' + results.A + results.B + ' occurs')
    }
)
console.log("event D occurs")

这里写图片描述

var async = require('async');

function exec(){
//串行无关联
    async.series(
        {   //这里面是串行的方法
            one : function(done){
                //回调函数写在这 
                var i = 0;
                /*
                setTimeout(function(){
                    console.log("oneFun");
                },1000);//1秒之后调用
                */
                setInterval(function(){
                    console.log("oneFun");
                    i++;
                    if(i == 3){
                        clearInterval(this);
                        done('错误','one完毕');
                    }
                },1000);//每隔1秒调用一次
            },
            two : function(done){
                    var j = 0;
                    setInterval(function(){
                        console.log("twoFun");
                        j++;
                        if(j == 3){
                            clearInterval(this);
                            done(null,'two完毕');
                        }
                    },1000);//每隔1秒调用一次
            }
        },function(err,rs){
            console.log(err);
            console.log(rs);
        }   
    )
}

exec();

console.log("end");

这里写图片描述

oneFun的done出现错误，所以被拦截了，所以twoFun就不会执行。

注意：如果任何一个方法在callback中返回了一个异常错误，停止后续方法的执行，且async.series的回调立即执行。

async.parallel

  • async.parallel可以接受对象作为参数
var async = require('async');
function exec(){
//并行无关联
    async.parallel(
        {   
            one : function(done){
                //回调函数写在这 
                var i = 0;
                /*
                setTimeout(function(){
                    console.log("oneFun");
                },1000);//1秒之后调用
                */
                setInterval(function(){
                    console.log("oneFun");
                    i++;
                    if(i == 3){
                        clearInterval(this);
                        done(null,'one完毕');
                    }
                },1000);//每隔1秒调用一次
            },
            two : function(done){
                    var j = 0;
                    setInterval(function(){
                        console.log("twoFun");
                        j++;
                        if(j == 3){
                            clearInterval(this);
                            done(null,'two完毕');
                        }
                    },1000);//每隔1秒调用一次
            }
        },function(err,rs){
            console.log(err);
            console.log(rs);
        }   
    )
}

exec();

console.log("end");

这里写图片描述

  • async.parallel可以接受数组作为参数
var async = require('async');

async.parallel(
    [
        function (callback) {
            setTimeout(function () {
                console.log('event A occurs')
                callback(null, 'A')
            }, 3000)
        },
        function (callback) {
            console.log('event B occurs')
            callback(null, 'B')
        }
    ], function (err, result) {
        console.log("event C occurs")
         console.log(result)
    }
)
console.log("event D occurs")

这里写图片描述

var async = require('async');
function exec(){
//并行无关联
    async.parallel(
        {   
            one : function(done){
                //回调函数写在这 
                var i = 0;
                /*
                setTimeout(function(){
                    console.log("oneFun");
                },1000);//1秒之后调用
                */
                setInterval(function(){
                    console.log("oneFun");
                    i++;
                    if(i == 3){
                        clearInterval(this);
                        done('错误','one完毕');
                    }
                },1000);//每隔1秒调用一次
            },
            two : function(done){
                    var j = 0;
                    setInterval(function(){
                        console.log("twoFun");
                        j++;
                        if(j == 3){
                            clearInterval(this);
                            done(null,'two完毕');
                        }
                    },1000);//每隔1秒调用一次
            }
        },function(err,rs){
            console.log(err);
            console.log(rs);
        }   
    )
}

exec();

console.log("end");

这里写图片描述

注意：
1、并行执行，所有任务执行完后，立即执行回调函数。
2、如果有一个任务执行异常报错，立即执行回调函数。

async.waterfall

waterfall：串行，前一个任务的结果传递给后一个任务。

var async = require('async');

function exec(){
    async.waterfall(
        [   
            function(done){
                //回调函数写在这 
                var i = 0;
                /*
                setTimeout(function(){
                    console.log("oneFun");
                },1000);//1秒之后调用
                */
                setInterval(function(){
                    console.log("oneFun");
                    i++;
                    if(i == 3){
                        clearInterval(this);
                        done(null,'one完毕'); // 第一个参数是error，第二个参数是下一个任务的参数
                    }
                },1000);//每隔1秒调用一次
            },
            function(preValue,done){
                    var j = 0;
                    setInterval(function(){
                        console.log("twoFun");
                        j++;
                        if(j == 3){
                            clearInterval(this);
                            done(null,preValue + ',two完毕');
                        }
                    },1000);//每隔1秒调用一次
            }
        ],function(err,rs){
            console.log(err);
            console.log(rs);
        }   
    )
}

exec();

console.log("end");

这里写图片描述

var async = require('async');

function exec(){
    async.waterfall(
        [   
            function(done){
                //回调函数写在这 
                var i = 0;
                /*
                setTimeout(function(){
                    console.log("oneFun");
                },1000);//1秒之后调用
                */
                setInterval(function(){
                    console.log("oneFun");
                    i++;
                    if(i == 3){
                        clearInterval(this);
                        done(null,'one完毕');
                    }
                },1000);//每隔1秒调用一次
            },
            function(preValue,done){
                    var j = 0;
                    setInterval(function(){
                        console.log(preValue + "twoFun");
                        j++;
                        if(j == 3){
                            clearInterval(this);
                            done(null,preValue + ',two完毕');
                        }
                    },1000);//每隔1秒调用一次
            }
        ],function(err,rs){
            console.log(err);
            console.log(rs);
        }   
    )
}

exec();

console.log("end");

这里写图片描述

c.
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
node 中的异步
qq_37653449的博客
04-21 1020
Node在*nix平台下采用了libeio配合libev实现I/O部分，实现了异步I/O 在Node v0.9.3中，自行实现了线程池来完成异步I/O libeio 实质上依然是采用线程池与阻塞I/O模拟异步I/O Node在Windows下采用IOCP来实现异步I/O 完成整个异步I/O环节的有事件循环、观察者 和 请求对象等。 事件循环 白话讲解： 这个过程就如同饭馆的厨房，厨房一轮一...
nodejs异步流程控制
影子
08-30 462
场景： 1、图片上传服务器 2、图片写入磁盘 3、图片写入数据库 在nodejs里面这三种方式都是异步操作，不想java其他语言同步进行，这就需要对异步流程进行控制，保证1,2,3逐步进行。有可能1还没完成，2和3可能就开始了，所以需要控制流程。 异步流程控制对象async 1、串行无关联：async.series（1,2,3按照顺序执行） 2、并行无关联：async.parallel（1,2,3一起跑） 3、串行有关联：waterfall（瀑布流关系，1完成传给2,2完成传给3） 4、pa
Nodejs 异步I/O
SK_study的博客
02-06 1896
学习 Node 异步编程，了解大型项目用 Node 作为中间层思想原理。
JavaScript在Node.js中如何管理异步操作？有哪些异步编程模式？
最新发布
AntonioMargery的博客
04-25 874
此外，事件驱动模式、发布/订阅模式、回调函数链模式和流模式等也是Node.js中常见的异步编程模式，它们为开发者提供了灵活且强大的异步处理能力。在Node.js中，JavaScript通过非阻塞I/O模型进行异步操作，这种模型使得Node.js能够处理高并发场景，并且有着出色的性能。管理异步操作是Node.js编程的核心部分，本文将探讨JavaScript在Node.js中如何管理异步操作，以及常见的异步编程模式。当一个异步操作完成后，Node.js会调用一个预先设定的函数，这个函数就是回调函数。
Node 处理异步的方式
越陌度阡
07-14 1299
Node.js以异步著称，性能非常的好，但是在开发过程中我们时常要规避一些异步执行，要让程序按同步执行，如下的代码可以说明存在的问题。 var fs=require('fs'); console.log('1'); fs.readFile('FileType.json',function(err,data){ console.log('2'); }); console.log('......
Nodejs异步流程控制Async
fens的博客
09-13 351
从零开始nodejs系列文章，将介绍如何利Javascript做为服务端脚本，通过Nodejs框架web开发。Nodejs框架是基于V8的引擎，是目前速度最快的Javascript引擎。chrome浏览器就基于V8，同时打开20-30个网页都很流畅。Nodejs标准的web开发框架Express，可以帮助我们迅速建立web站点，比起PHP的...
Node.js-StuQ分享专题《深入浅出jsNode.js异步流程控制》完整版
08-10
本专题《深入浅出js（Node.js）异步流程控制》将探讨Node.js中的异步编程这一核心概念，帮助开发者更深入地理解和掌握这一技术。 异步编程是Node.js的核心特性之一，它允许程序在等待I/O操作完成时继续执行其他任务...
Node.js异步编程
10-09
另外，还有一些库如async、bluebird等，进一步帮助开发者更好地管理和控制异步流程。 在Node.js中，异常处理也是异步编程的一部分。由于回调地狱可能导致深层嵌套，因此使用try/catch结构可以捕获并处理异步操作中...
Node.js安装包压缩包
09-28
Node.js是一种开源、跨平台的JavaScript运行环境，它允许开发者在服务器端运行JavaScript代码，极大地扩展了JavaScript的应用范围。Node.js基于Chrome V8引擎，因此它具有高性能和高效率的特点。这个压缩包文件包含...
基于Node.js的高并发电商购物系统设计与实现
04-30
Node.js是一个基于Chrome V8引擎的JavaScript运行环境，以其异步非阻塞I/O和事件驱动的特性，非常适合处理大量并发请求。在系统设计中，首先会构建一个高速静态资源服务器，通过CDN(Content Delivery Network)结合...
Node.js的异步I/O
02-25
首先，我们着重强调一下Node自身的执行模型——事件循环，正是它使得回调函数十分普遍。在进程启动时，Node便会创建一个类似于while(true)的循环，每执行一次循环体的过程我们称为Tick。每个Tick的过程就是查看是否...
Nodejs 异步流程控制（上）
凯歌技术控团队
12-02 405
【代码】Nodejs 异步流程控制（上）
Node.js中流程控制
weixin_30323631的博客
06-11 79
Node.js中的流程控制可以使用async,在使用之前需要先安装，使用npm安装 npm install async --g 下面主要介绍4种流程控制的方式： 1、串行无关联：async.series(tasks,callback) 多个函数依次执行,之间没有数据交换,其中一个函数出错，后续函数不再执行; 以下是标准写法： async.series({ ...
NodeJS的异步、并发编程方案
书生的博客
05-24 8484
一、事件发布/订阅模式（events） 事件发布/订阅模式自身并无同步和异步的问题，但在node中，emit()调用多半是伴随时间循环而异步触发的。 订阅： emitter.on("event1", function(message){ console.log(message); }); 发布 emitter.emit("event1&a
node.js在遇到“循环+异步”时的注意事项
热门推荐
fangjian1204的专栏
01-26 1万+
nodejs的特征nodejs的最大特征就是一切都是基于事件的，从而导致一切都是异步的。nodejs的速度为什么快，其原理和nginx一样，他们都是通过事件回调来处理请求的，从而导致了整个处理过程中，不会阻塞nodejs，因此，其在同一时间内可以处理大量的请求，而这种优越性在你的请求是IO密集型的情况下，表现的尤为突出。下面的例子简单说明了基于异步事件的nodejs的处理流程：var send_da
node.js 中的流程控制一
在梦中享一刻静谧，等待梦中的你
05-22 677
摘要: 对于在node这种异步框架下的编程，唯一的难题是：如何控制哪些函数顺序执行，哪些函数并行执行。node中并没有内置的控制方法，在这里我分享编写本站程序时用到的一些技巧。 并行VS顺序 在应用程序中通常有一些步骤必须在先前的操作得出结果之后才能运行。在平常的顺序... 对于在node这种异步框架下的编程，唯一的难题是：如何控制哪些函数顺序执行，哪些函数并行执行。node中并没有内置
Nodejs中控制异步的几种方法【陆续更新……】
geishel的博客
03-21 999
1.异步回调原生写法 serverClient.get("http://localhost:3001/test/test.php?page=1&page_count=1", function (err,res,data1) { // something serverClient.get("http://localhost:3001/test/test.php?page=2&p
Nodejs 异步流程控制（下）
凯歌技术控团队
12-02 249
【代码】Nodejs 异步流程控制（下）
nodejs异步的首次实践
蛋糕店的夏天
01-23 346
最近开始学习nodejs，照着《使用 eventproxy 控制并发》敲一遍代码，运行后发现打印的 fetch url 和前面 console.log(topicUrls) url 顺序不一样。 然后我在 get 方法上面添加一行打印： topicUrls.forEach( function (topicUrl) { console.log('get ' + topicUrl)
Node.js最新技术栈之Promise篇1
08-04
Node.js最新技术栈之Promise篇是关于JavaScript流程控制的进展过程的一系列教程，其中涵盖了回调函数Callbacks、异步JavaScript、生成器Generators/ yield、Promise/a以及Async/await。本文将对这些内容进行总结，并...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值