nodejs中Async库介绍

最新推荐文章于 2024-03-19 09:37:03 发布
最新推荐文章于 2024-03-19 09:37:03 发布
阅读量690 收藏
点赞数
分类专栏： 网络编程 node.js 文章标签： nodejs js

原帖地址：http://my.oschina.net/huangsz/blog/176203


地址：https://github.com/caolan/async 
Async的内容分为三部分：

  • 流程控制：简化十种常见流程的处理
  • 集合处理：如何使用异步操作处理集合中的数据
  • 工具类：几个常用的工具类

本文介绍其中最简单最常用的流程控制部分。 
由于nodejs是异步编程模型，有一些在同步编程中很容易做到的事情，现在却变得很麻烦。Async的流程控制就是为了简化这些操作。

series(tasks, [callback]) （多个函数依次执行，之间没有数据交换）

有多个异步函数需要依次调用，一个完成之后才能执行下一个。各函数之间没有数据的交换，仅仅需要保证其执行顺序。这时可使用series。 
纯js代码：

1 step1(function(err, v1) {
2         step2(function(err, v2) {
3                 step3(function(err, v3) {
4                         // do somethig with the err or values v1/v2/v3
5                 }
6         }
7 });

从中可以看到这嵌套还是比较多深的，如果再多几步，会更深。在代码中忽略对了每一层err的处理，否则还都等加上 if(err) return callback(err)，那就更麻烦了。 
对于这种情况，使用async来处理，就是这样的：

1 var async = require(‘async’) async.series([step1, step2, step3],
2 function(err, values) {
3         // do somethig with the err or values v1/v2/v3
4 });

可以看到代码简洁了很多，而且自动处理每个回调中的错误。当然，这里只给出来最最简单的例子，在实际中，我们常会在每个step中执行一些操作，这时可写成：

01 var async = require(‘async’) async.series([function(cb) {
02         step1(function(err, v1) {
03                 // do something with v1
04                 cb(err, v1);
05         }),
06         function(cb) {
07                 step2(...)
08         },
09         function(cb) {
10                 step3(...)
11         }],
12         function(err, values) {
13                 // do somethig with the err or values v1/v2/v3
14         });

该函数的详细解释为： 
依次执行一个函数数组中的每个函数，每一个函数执行完成之后才能执行下一个函数。 
如果任何一个函数向它的回调函数中传了一个error，则后面的函数都不会被执行，并且将会立刻会将该error以及已经执行了的函数的结果，传给series中最后那个callback。 
当所有的函数执行完后（没有出错），则会把每个函数传给其回调函数的结果合并为一个数组，传给series最后的那个callback。 
还可以json的形式来提供tasks。每一个属性都会被当作函数来执行，并且结果也会以json形式传给series最后的那个callback。这种方式可读性更高一些。 
具体例子可参考：https://github.com/freewind/async_demo/blob/master/series.js 
其代码中还包含了： 
如果中间某个函数出错，series函数如何处理 
如果某个函数传给回调的值为undefined, null, {}, []等，series如何处理 
另外还需要注意的是：多个series调用之间是不分先后的，因为series本身也是异步调用。

parallel(tasks, [callback]) （多个函数并行执行）

并行执行多个函数，每个函数都是立即执行，不需要等待其它函数先执行。传给最终callback的数组中的数据按照tasks中声明的顺序，而不是执行完成的顺序。 
如果某个函数出错，则立刻将err和已经执行完的函数的结果值传给parallel最终的callback。其它未执行完的函数的值不会传到最终数据，但要占个位置。 
同时支持json形式的tasks，其最终callback的结果也为json形式。 
示例代码：

01 async.parallel([function(cb) {
02         t.fire('a400', cb, 400)
03 },
04 function(cb) {
05         t.fire('a200', cb, 200)
06 },
07 function(cb) {
08         t.fire('a300', cb, 300)
09 }],
10 function(err, results) {
11         log(’1 err: ‘, err); // -> undefined
12         log(’1 results: ‘, results); // ->[ 'a400', 'a200', 'a300' ]
13 });

中途出错的示例：

01 async.parallel([function(cb) {
02         log('1: ', 'start');
03         t.fire('a400', cb, 400)
04 },
05 // 该函数的值不会传给最终callback，但要占个位置
06 function(cb) {
07         log('2: ', 'start');
08         t.err('e200', cb, 200)
09 },
10 function(cb) {
11         log('3: ', 'start');
12         t.fire('a100', cb, 100)
13 }],
14 function(err, results) {
15         log(’2 err: ‘, err); // -> e200
16         log(’2 results: ‘, results); // -> [ , undefined, 'a100' ]
17 });

以json形式传入tasks

01 async.parallel({
02         a: function(cb) {
03                 t.fire(‘a400′, cb, 400)
04         },
05         b: function(cb) {
06                 t.fire(‘c300′, cb, 300)
07         }
08 },
09 function(err, results) {
10         log(’3 err: ‘, err); // -> undefined
11         log(’3 results: ‘, results); // -> { b: ‘c300′, a: ‘a400′ }
12 });

更详细示例参见：https://github.com/freewind/async_demo/blob/master/parallel.js

waterfall(tasks, [callback]) （多个函数依次执行，且前一个的输出为后一个的输入）

与seires相似，按顺序依次执行多个函数。不同之处，每一个函数产生的值，都将传给下一个函数。如果中途出错，后面的函数将不会被执行。错误信息以及之前产生的结果，将传给waterfall最终的callback。 
这个函数名为waterfall(瀑布)，可以想像瀑布从上到下，中途冲过一层层突起的石头。注意，该函数不支持json格式的tasks。

01 async.waterfall([function(cb) {
02         log('1: ', 'start');
03         cb(null, 3);
04 },
05 function(n, cb) {
06         log('2: ', n);
07         t.inc(n, cb);
08 },
09 function(n, cb) {
10         log('3: ', n);
11         t.fire(n * n, cb);
12 }],
13 function(err, result) {
14         log(’1 err: ‘, err); // -> null
15         log(’1 result: ‘, result); // -> 16
16 });

更详细示例参见：https://github.com/freewind/async_demo/blob/master/waterfall.js

auto(tasks, [callback]) （多个函数有依赖关系，有的并行执行，有的依次执行）

用来处理有依赖关系的多个任务的执行。比如某些任务之间彼此独立，可以并行执行；但某些任务依赖于其它某些任务，只能等那些任务完成后才能执行。 
虽然我们可以使用async.parallel和async.series结合起来实现该功能，但如果任务之间关系复杂，则代码会相当复杂，以后如果想添加一个新任务，也会很麻烦。这时使用async.auto，则会事半功倍。 
如果有任务中途出错，则会把该错误传给最终callback，所有任务（包括已经执行完的）产生的数据将被忽略。 
这里假设我要写一个程序，它要完成以下几件事： 
从某处取得数据 
在硬盘上建立一个新的目录 
将数据写入到目录下某文件 
发送邮件，将文件以附件形式发送给其它人。 
分析该任务，可以知道1与2可以并行执行，3需要等1和2完成，4要等3完成。

01 async.auto({
02         getData: function(callback) {
03                 setTimeout(function() {
04                         console.log(’1 : got data’);
05                         callback();
06                 },
07                 300);
08         },
09         makeFolder: function(callback) {
10                 setTimeout(function() {
11                         console.log(’1 : made folder’);
12                         callback();
13                 },
14                 200);
15         },
16         writeFile: ['getData', 'makeFolder',
17         function(callback) {
18                 setTimeout(function() {
19                         console.log('1: wrote file');
20                         callback(null, 'myfile');
21                 },
22                 300);
23         }],
24         emailFiles: ['writeFile',
25         function(callback, results) {
26                 log('1: emailed file: ', results.writeFile); // -> myfile
27                 callback(null, results.writeFile);
28         }]
29 },
30 function(err, results) {
31         log(’1 : err: ‘, err); // -> null
32         log(’1 : results: ‘, results); // -> { makeFolder: undefined,
33         // getData: undefined,
34         // writeFile: ‘myfile’,
35         // emailFiles: ‘myfile’ }
36 });

更多详细示例参见：https://github.com/freewind/async_demo/blob/master/auto.js

whilst(test, fn, callback)（用可于异步调用的while）

相当于while，但其中的异步调用将在完成后才会进行下一次循环。举例如下：

01 var count1 = 0;
02 async.whilst(function() {
03         return count1 < 3
04 },
05 function(cb) {
06         log(’1 count: ‘, count1);
07         count1++;
08         setTimeout(cb, 1000);
09 },
10 function(err) {
11         // 3s have passed
12         log(’1 err: ‘, err); // -> undefined
13 });

它相当于：

1 try {
2     whilst(test) {
3         fn();
4     }
5     callback();
6 } catch(err) {
7     callback(err);
8 }

该函数的功能比较简单，条件变量通常定义在外面，可供每个函数访问。在循环中，异步调用时产生的值实际上被丢弃了，因为最后那个callback只能传入错误信息。 
另外，第二个函数fn需要能接受一个函数cb，这个cb最终必须被执行，用于表示出错或正常结束。 
更详细示例参见：https://github.com/freewind/async_demo/blob/master/whilst_until.js

until(test, fn, callback) （与while相似，但判断条件相反）

01 var count4 = 0;
02  async.until(function() {
03      return count4 > 3
04  },
05  function(cb) {
06      log(’4 count: ‘, count4);
07      count4++;
08      setTimeout(cb, 200);
09  },
10  function(err) {
11      // 4s have passed
12      log(’4 err: ‘, err); // -> undefined
13  });

当第一个函数条件为false时，继续执行第二个函数，否则跳出。

queue （可设定worker数量的队列）

queue相当于一个加强版的parallel，主要是限制了worker数量，不再一次性全部执行。当worker数量不够用时，新加入的任务将会排队等候，直到有新的worker可用。 
该函数有多个点可供回调，如worker用完时、无等候任务时、全部执行完时等。 
定义一个queue，其worker数量为2，并在任务执行时，记录一下日志：

1 var q = async.queue(function(task, callback) {
2     log(‘worker is processing task: ‘, task.name);
3     task.run(callback);
4 }, 2);

worker数量将用完时，会调用saturated函数：

1 q.saturated = function() {
2        log(‘all workers to be used’);
3    }

当最后一个任务交给worker执行时，会调用empty函数

1 q.empty = function() {
2        log(‘no more tasks wating’);
3    }

当所有任务都执行完时，会调用drain函数

1 q.drain = function() {
2        console.log(‘all tasks have been processed’);
3    }

放入多个任务，可一次放一个，或一次放多个

01 q.push({
02         name: ’t1′,
03         run: function(cb) {
04                 log(‘t1 is running, waiting tasks: ‘, q.length());
05                 t.fire(‘t1′, cb, 400); // 400ms后执行
06         }
07 },
08 function(err) {
09         log(‘t1 executed’);
10 });
11  
12 q.push([{
13         name: 't3',
14         run: function(cb) {
15                 log('t3 is running, waiting tasks: ', q.length());
16                 t.fire('t3', cb, 300); // 300ms后执行
17         }
18 },
19 {
20         name: 't4',
21         run: function(cb) {
22                 log('t4 is running, waiting tasks: ', q.length());
23                 t.fire('t4', cb, 500); // 500ms后执行
24         }
25 }],
26 function(err) {
27         log(‘t3 / 4 executed’);
28 });

更多详细示例参见：https://github.com/freewind/async_demo/blob/master/queue.js

iterator(tasks) （将几个函数包装为iterator）

将一组函数包装成为一个iterator，可通过next()得到以下一个函数为起点的新的iterator。该函数通常由async在内部使用，但如果需要时，也可在我们的代码中使用它。

01 var iter = async.iterator([function() {
02         console.log('111')
03 },
04 function() {
05         console.log('222')
06 },
07 function() {
08         console.log('333')
09 }]);
10 console.log(iter());
11 console.log(iter.next());

直接调用()，会执行当前函数，并返回一个由下个函数为起点的新的iterator。调用next()，不会执行当前函数，直接返回由下个函数为起点的新iterator。 
对于同一个iterator，多次调用next()，不会影响自己。如果只剩下一个元素，调用next()会返回null。 
更详细示例参见：https://github.com/freewind/async_demo/blob/master/iterator.js

apply(function, arguments..) （给函数预绑定参数）

apply是一个非常好用的函数，可以让我们给一个函数预绑定多个参数并生成一个可直接调用的新函数，简化代码。 
对于函数：

1 function(callback) { t.inc(3, callback); }

可以用apply改写为：

1 async.apply(t.inc, 3);

还可以给某些函数预设值，得到一个新函数：

1 var log = async.apply(console.log, ">");
2    log(‘hello’);
3    // > hello

更详细代码参见：https://github.com/freewind/async_demo/blob/master/apply.js

nextTick(callback) （在nodejs与浏览器两边行为一致）

nextTick的作用与nodejs的nextTick一样，都是把某个函数调用放在队列的尾部。但在浏览器端，只能使用setTimeout(callback,0)，但这个方法有时候会让其它高优先级的任务插到前面去。 
所以提供了这个nextTick，让同样的代码在服务器端和浏览器端表现一致。

1 var calls = [];
2 async.nextTick(function() {
3         calls.push(‘two’);
4 });
5 calls.push(‘one’);
6 async.nextTick(function() {
7         console.log(calls); // -> [ 'one', 'two' ]
8 });

更详细代码参见：https://github.com/freewind/async_demo/blob/master/nextTick.js


async-wait-until：使用方便的Promise API等待给定的回调返回真实值
02-03
异步等待直到 等待谓词为真并解决一个承诺。 该库提供TypeScript定义。 无需依赖。 请确保您的环境具有Promise支持（或具有polyfill）。 安装 $ npm install --save async-wait-until 用法 下面描述了简单的用例： const waitUntil = require ( 'async-wait-until' ) ; const timeOfStart = Date . now ( ) ; // Wait for some async operation to end waitUntil ( ( ) => { const timePas
Async详解之一：流程控制
rayi_hong的专栏
03-23 911
转载：http://freewind.me/blog/20120515/917.html 为了适应异步编程，减少回调的嵌套，我尝试了很多库。最终觉得还是async最靠谱。 地址：https://github.com/caolan/async Async的内容分为三部分： 流程控制：简化十种常见流程的处理集合处理：如何使用异步操作处理集合中的数据工具类：几个常用的工具类 本文介绍其
Appium-Execute Async（执行异步）
weixin_45576146的博客
04-21 897
Execute Async ScriptExample UsageDescriptionSupportAppium ServerAppium ClientsHTTP API SpecificationsEndpointURL ParametersJSON ParametersResponse Inject a snippet of JavaScript into the page for execution in the context of the currently selected frame (We
nodejs async 库使用
在梦中享一刻静谧，等待梦中的你
07-25 7639
var async = require('async'); var util = require('util') //将一个Array中的元素，按照一定的规则转换，得到一个新的数组（元素个数不变) var Arr=[1,2,3,4,5]; async.map(Arr,function(item,callback){ var _setValue = parseInt(item)+1;
深入学习nodejs中的async模块的使用方法
10-19
首先，async模块可以通过npm进行安装，使用命令`npm install async`，然后在JavaScript文件中通过`var async = require('async');`的方式引入模块。 series方法允许开发者将多个异步任务按照顺序执行，即一个任务...
nodejs async异步常用函数总结（推荐）
10-18
以下是async库中一些常用异步函数的介绍以及知识点总结： 1. async.map()和async.mapSeries() async.map()函数用于将一个数组转换成另一个数组，每个数组元素都会异步地经过一个指定的函数处理，然后将结果汇总到一...
Nodejs异步流程框架async的方法
10-16
下面将详细介绍async库中的一些核心方法。 1. **async.series** `async.series` 用于执行一系列函数，这些函数按顺序执行，彼此之间没有依赖关系。每个函数完成之后，才会执行下一个。这对于那些需要按照特定顺序...
async/await与promise（nodejs中的异步操作问题）
10-20
综上所述，`async/await`配合Promise为Node.js中的异步操作提供了一种清晰且有效的方法。它不仅避免了回调地狱，还使得异步代码更易于理解和维护，大大提升了开发者的编程体验。随着JavaScript和Node.js的发展，这些...
AsyncTask中execute()延时执行原因
lea_fy的博客
07-19 1219
AsyncTask中execute()延时执行原因一般都是skd版本的问题，我们都知道，AsyncTas是在一个独立的线程中顺序执行的，也就是说，它每次只能执行一个任务，不能同时进行多个任务。       在1.6版本开始，它加入了线程池的概念，能够同时进行5个任务，超过的只能等待着5个执行完再执行，所以说AsyncTask中execute()延时执行原因主要就在这里，你延时执行的异步操作可能就
用Async解决回调问题
前端达人
09-27 2413
概述第一次接触编程时，我们就知道了一块代码是从头执行到尾的。 这就是所谓的同步编程：每个操作完成之后，后面的才会继续。 对于不花计算机太多时间的操作，比如数字相加、操作字...
@Async异步功能
诚的博客
01-30 519
@Async注解，可以实现异步处理的功能，它可以有返回值，或者直接在新线程时并行执行一个任务，对于异步来说，它的执行是有条件的，你需要把异步代码块放在单独的类里，当spring在注入时，才不会相互影响，因为异步是一个比较特殊的代理。 异步入口 @EnableAsync 具体的异步方法 /** * 异常的类型应该和同步执行的类分开，这样在ioc建立时不会相互干扰 */ @Service public class MessageService { @Async public void
面试官：Vue中的$nextTick怎么理解?
iygxv
01-13 2067
故心故心故心故心小故冲啊 文章目录一、NextTick是什么为什么要有nexttick二、使用场景三、实现原理小结：参考文献 一、NextTick是什么 官方对其的定义 在下次 DOM 更新循环结束之后执行延迟回调。在修改数据之后立即使用这个方法，获取更新后的 DOM 就是可以立即获取dom更新后的数据进行更新 举例一下 Html结构 <div id="app"> {{ message }} </div> 构建一个vue实例 const vm = new Vue({.
使用异步解决回调问题
代码教主
06-13 848
当我们第一次开始编程时，我们了解到代码块是从上到下执行的。 这是同步编程：每个操作都在下一个操作开始之前完成。 当您要做很多事情而计算机几乎不需要时间来完成时，例如添加数字，操作字符串或分配变量，这非常好。 当您想要花费较长时间执行某项操作（例如访问磁盘上的文件，发送网络请求或等待计时器过去）时，会发生什么情况？ 在同步编程中，您的脚本在等待时无法执行其他操作。 对于简单的事情或在脚本...
Nodejs异步流程控制Async
fens的博客
09-13 395
从零开始nodejs系列文章，将介绍如何利Javascript做为服务端脚本，通过Nodejs框架web开发。Nodejs框架是基于V8的引擎，是目前速度最快的Javascript引擎。chrome浏览器就基于V8，同时打开20-30个网页都很流畅。Nodejs标准的web开发框架Express，可以帮助我们迅速建立web站点，比起PHP的...
SpringBoot通过线程池试实现异步任务
qq_42688149的博客
07-15 529
SpringBoot通过线程池试实现异步任务1 配置application.properties文件2 线程池配置类3 异步接口和异步具体实现类4 Controller调用接口5 运行结果6 自定义线程池显示信息 1 配置application.properties文件 # 异步线程配置 #核心线程数 async.executor.thread.core_pool_size=5 #配置最大线程数 async.executor.thread.max_pool_size=10 #配置队列大小 async.e
使用 async await + setTimeout 分割 while 循环
liuyaqi1993的博客
03-27 5888
由于JavaScript单线程的特性，在执行CPU密集型任务时（如大数组排序）会阻塞网页的渲染，解决办法一般是使用setTimeout函数对任务进行分割，或者把这类任务交由 web worker 处理。今天遇到一个对大数组排序的问题，需要使用任务分割来避免阻塞，在这里记录下我的实现方法。在实现时我将 while 语句进行了分割，避免出现大循环体语句一直进行计算，主要代码如下： // ...
推荐开源项目：Async - 简洁高效的异步流程控制库
gitblog_00068的博客
03-19 659
推荐开源项目：Async - 简洁高效的异步流程控制库 asyncAsync utilities for node and the browser项目地址:https://gitcode.com/gh_mirrors/as/async 是一个由 Caolan Andrew 开发并维护的 JavaScript 库，专为 Node.js 和浏览器环境设计，用于处理复杂的异步控制流。在现代 web 开...
超级实用！详解Node.js中的lodash模块和async模块
你若盛开，清风自来
06-30 1552
lodash 是一个流行的 JavaScript 实用工具库，提供了许多方便的函数来简化 JavaScript 编程。它提供了大量可靠且高效的工具函数，可以帮助开发者处理数组、对象、函数和其他数据类型，提供了更简洁、更强大的方法来操作和处理数据。
nodejs 使用async/await的好处
最新发布
12-04
Node.js 中的 `async/await` 提供了一种更直观的方式来编写异步代码，相比于传统的回调函数或Promise链式调用，它使得代码更加简洁易读。以下是使用 async/await 的好处： 1. **易于理解**[^1]: 使用 `async` 和 `...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值