nodejs中Async库介绍

最新推荐文章于 2023-03-01 22:22:10 发布
最新推荐文章于 2023-03-01 22:22:10 发布
阅读量630 收藏 2
点赞数
文章标签： nodejs async

地址：https://github.com/caolan/async
Async的内容分为三部分：
1.流程控制：简化十种常见流程的处理
2.集合处理：如何使用异步操作处理集合中的数据
3.工具类：几个常用的工具类
本文介绍其中最简单最常用的流程控制部分。
由于nodejs是异步编程模型，有一些在同步编程中很容易做到的事情，现在却变得很麻烦。Async的流程控制就是为了简化这些操作。

1. 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’) 
  2. async.series([ 
  3.    step1, step2, step3 
  4. ], function(err, values) { 
  5.    // do somethig with the err or values v1/v2/v3 
  6. });


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

 
 
  1. var async = require(‘async’) 
  2. async.series([ 
  3.   function(cb) { step1(function(err,v1) {
  4.      // do something with v1 
  5.      cb(err, v1); 
  6.   }), 
  7.   function(cb) { step2(...) }, 
  8.   function(cb) { step3(...) } 
  9. ], function(err, values) {
  10. // do somethig with the err or values v1/v2/v3
  11. });

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

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

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

 
 
  1. async.parallel([ 
  2.     function(cb) { t.fire('a400', cb, 400) }, 
  3.     function(cb) { t.fire('a200', cb, 200) }, 
  4.     function(cb) { t.fire('a300', cb, 300) } 
  5. ], function (err, results) { 
  6.     log(’1.1 err: ‘, err); // -> undefined 
  7.     log(’1.1 results: ‘, results); // ->[ 'a400', 'a200', 'a300' ] 
  8. });

中途出错的示例：

 
 
  1. async.parallel([ 
  2.     function(cb) { log('1.2.1: ', 'start'); t.fire('a400', cb, 400) }, // 该函数的值不会传给最终callback，但要占个位置 
  3.     function(cb) { log('1.2.2: ', 'start'); t.err('e200', cb, 200) }, 
  4.     function(cb) { log('1.2.3: ', 'start'); t.fire('a100', cb, 100) } 
  5. ], function(err, results) { 
  6.     log(’1.2 err: ‘, err); // -> e200 
  7.     log(’1.2 results: ‘, results); // -> [ , undefined, 'a100' ] 
  8. });

以json形式传入tasks

 
 
  1. aasync.parallel({ 
  2.     a: function(cb) { t.fire(‘a400′, cb, 400) }, 
  3.     b: function(cb) { t.fire(‘c300′, cb, 300) } 
  4. }, function(err, results) { 
  5.     log(’1.3 err: ‘, err); // -> undefined 
  6.     log(’1.3 results: ‘, results); // -> { b: ‘c300′, a: ‘a400′ } 
  7. });

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

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

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

 
 
  1. async.waterfall([ 
  2.     function(cb) { log('1.1.1: ', 'start'); cb(null, 3); }, 
  3.     function(n, cb) { log('1.1.2: ',n); t.inc(n, cb); }, 
  4.     function(n, cb) { log('1.1.3: ',n); t.fire(n*n, cb); } 
  5. ], function (err, result) { 
  6.     log(’1.1 err: ‘, err); // -> null 
  7.     log(’1.1 result: ‘, result); // -> 16 
  8. });

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

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

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

 
 
  1. async.auto({ 
  2.     getData: function (callback) { 
  3.         setTimeout(function(){ 
  4.             console.log(’1.1: got data’); 
  5.             callback(); 
  6.         }, 300); 
  7.     }, 
  8.     makeFolder: function (callback) { 
  9.         setTimeout(function(){ 
  10.             console.log(’1.1: made folder’); 
  11.             callback(); 
  12.         }, 200); 
  13.     }, 
  14.     writeFile: ['getData', 'makeFolder', function(callback) { 
  15.         setTimeout(function(){ 
  16.             console.log('1.1: wrote file'); 
  17.             callback(null, 'myfile'); 
  18.         }, 300); 
  19.     }], 
  20.     emailFiles: ['writeFile', function(callback, results) { 
  21.         log('1.1: emailed file: ', results.writeFile); // -> myfile 
  22.         callback(null, results.writeFile); 
  23.     }] 
  24. }, function(err, results) { 
  25.     log(’1.1: err: ‘, err); // -> null 
  26.     log(’1.1: results: ‘, results); // -> { makeFolder: undefined, 
  27.                                     //      getData: undefined, 
  28.                                     //      writeFile: ‘myfile’, 
  29.                                     //      emailFiles: ‘myfile’ } 
  30. });

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

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

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

 
 
  1. var count1 = 0; 
  2. async.whilst( 
  3.     function() { return count1 < 3 }, 
  4.     function(cb) { 
  5.         log(’1.1 count: ‘, count1); 
  6.         count1++; 
  7.         setTimeout(cb, 1000); 
  8.     }, 
  9.     function(err) { 
  10.         // 3s have passed 
  11.         log(’1.1 err: ‘, err); // -> undefined 
  12.     } 
  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

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

 
 
  1. var count4 = 0; 
  2. async.until( 
  3.     function() { return count4>3 }, 
  4.     function(cb) { 
  5.         log(’1.4 count: ‘, count4); 
  6.         count4++; 
  7.         setTimeout(cb, 200); 
  8.     }, 
  9.     function(err) { 
  10.         // 4s have passed 
  11.         log(’1.4 err: ‘,err); // -> undefined 
  12.     } 
  13. );

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

7. 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. }

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

 
 
  1. q.push({name:’t1′, run: function(cb){ 
  2.     log(‘t1 is running, waiting tasks: ‘, q.length()); 
  3.     t.fire(‘t1′, cb, 400); // 400ms后执行 
  4. }}, function(err) { 
  5.     log(‘t1 executed’); 
  6. });
 
 
  1. q.push([{name:'t3', run: function(cb){ 
  2.     log('t3 is running, waiting tasks: ', q.length()); 
  3.     t.fire('t3', cb, 300); // 300ms后执行 
  4. }},{name:'t4', run: function(cb){ 
  5.     log('t4 is running, waiting tasks: ', q.length()); 
  6.     t.fire('t4', cb, 500); // 500ms后执行 
  7. }}], function(err) { 
  8.     log(‘t3/4 executed’); 
  9. });

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

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

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

 
 
  1. var iter = async.iterator([ 
  2. function() { console.log('111') }, 
  3. function() { console.log('222') }, 
  4. function() { console.log('333') } 
  5. ]);
  6. console.log(iter());
  7. console.log(iter.next());

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

9. 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

10. 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

转载：http://zhangqi.im/webdevelopment/nodejsasyncone.html

x530731875
关注
使用 async await + setTimeout 分割 while 循环
liuyaqi1993的博客
03-27 5828
由于JavaScript单线程的特性，在执行CPU密集型任务时（如大数组排序）会阻塞网页的渲染，解决办法一般是使用setTimeout函数对任务进行分割，或者把这类任务交由 web worker 处理。今天遇到一个对大数组排序的问题，需要使用任务分割来避免阻塞，在这里记录下我的实现方法。在实现时我将 while 语句进行了分割，避免出现大循环体语句一直进行计算，主要代码如下： // ...
Nodejs中的异步编程类库Async
win0032的博客
05-21 466
今天在用mongodb和express中做博客时,教程中提到了对于mongodb的操作及回调的过程是典型的深度嵌套回调,代码如下Post.getOne = function(name, day, title, callback) { mongodb.open(function (err, db) { if (err) { ... } db.collection('posts'
Async详解之一：流程控制
rayi_hong的专栏
03-23 867
转载：http://freewind.me/blog/20120515/917.html 为了适应异步编程，减少回调的嵌套，我尝试了很多库。最终觉得还是async最靠谱。 地址：https://github.com/caolan/async Async的内容分为三部分： 流程控制：简化十种常见流程的处理集合处理：如何使用异步操作处理集合中的数据工具类：几个常用的工具类 本文介绍其
Nodejs异步流程控制Async
fens的博客
09-13 360
从零开始nodejs系列文章，将介绍如何利Javascript做为服务端脚本，通过Nodejs框架web开发。Nodejs框架是基于V8的引擎，是目前速度最快的Javascript引擎。chrome浏览器就基于V8，同时打开20-30个网页都很流畅。Nodejs标准的web开发框架Express，可以帮助我们迅速建立web站点，比起PHP的...
深入学习nodejs中的async模块的使用方法
10-19
首先，async模块可以通过npm进行安装，使用命令`npm install async`，然后在JavaScript文件中通过`var async = require('async');`的方式引入模块。 series方法允许开发者将多个异步任务按照顺序执行，即一个任务...
nodejs中async-lock模块使用
qq_44797761的博客
09-22 3002
资料： nodejs中的单进程异步锁——async-lock async-lock - npm 原理就是按队列执行（大概）
nodejs使用async模块同步执行的方法
10-17
在 Node.js 中，`async`模块提供了一系列的实用方法，可以帮助开发者处理复杂的异步逻辑。其中，`async.series`方法是用于确保一系列的异步任务按顺序执行，即一个任务开始前必须等待前一个任务完成，这一点在很多...
NodeJs通过async/await处理异步的方法
12-23
场景 远古时代 我们在编写express后台，经常要有许多异步IO的处理。在远古时代，我们都是用chunk函数处理，也就是我们最熟悉的那种默认第一个参数是error的函数。我们来模拟一个Mongo数据库的操作，感受一下。...
nodejs async 库使用
在梦中享一刻静谧，等待梦中的你
07-25 7601
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;
Async 例子
lihuifeng的博客
05-26 503
地址：https://github.com/caolan/async Async的内容分为三部分： 流程控制：简化十种常见流程的处理集合处理：如何使用异步操作处理集合中的数据工具类：几个常用的工具类 本文介绍其中最简单最常用的流程控制部分。 由于nodejs是异步编程模型，有一些在同步编程中很容易做到的事情，现在却变得很麻烦。Async的流程控制就是为了简化这些操作。 ser
nodejs async库初试牛刀
leol77的博客
04-19 334
写得程序需要多层的回调函数，太烦人了，于是调用了async.waterfall([],cb); 参数为一个函数数组，每个函数数组第一个为err,其他为result ,cb作为最后的回调来检测出现错误的信息和最终的结果 DiscuzRobot.generateTxt = function(path){ var later = require('later'); var dayup = lat
nodejs中的async模块学习
热门推荐
意外金喜
07-08 3万+
async模块是为了解决嵌套金字塔,和异步流程控制而生.常用的方法下面一一介绍 1. series(tasks,[callback]) 多个函数从上到下依次执行,相互之间没有数据交互 var task1 =function(callback){ console.log("task1"); callback(null,"task1") } var task2 =fun
Node.js异步库async
weixin_30493401的博客
10-18 120
async的使用需要安装第三方包 1.串行无关联 async.series 函数依次执行,后面不需要调前面步骤的结果 程序执行时间为所有步骤之和 2.并行无关联 async.paraller 某步出错不影响其他步骤执行 程序执行时间为最长的那个时间 3.串行有关联 async.waterfall 函数依次执行,后面需要调前面步骤的结果 程序执行时间为所有步骤...
在 Node.js 中使用 async 函数的方法
军火库
03-01 2199
借助于新版 V8 引擎，Node.js 从 7.6 开始支持 async 函数特性。今年 10 月 31 日，Node.js 8 也开始成为新的长期支持版本，因此你完全可以放心大胆地在你的代码中使用 async 函数了。在这边文章里，我会简要地介绍一下什么是 async 函数，以及它会如何改变我们编写 Node.js 应用的方式。利用 async 函数，你可以把基于 Promise 的异步代码写得就像同步代码一样。
@Async异步功能
诚的博客
01-30 500
@Async注解，可以实现异步处理的功能，它可以有返回值，或者直接在新线程时并行执行一个任务，对于异步来说，它的执行是有条件的，你需要把异步代码块放在单独的类里，当spring在注入时，才不会相互影响，因为异步是一个比较特殊的代理。 异步入口 @EnableAsync 具体的异步方法 /** * 异常的类型应该和同步执行的类分开，这样在ioc建立时不会相互干扰 */ @Service public class MessageService { @Async public void
python - asyncio异步编程 - 事件循环
qq_33962481的博客
04-28 518
文章目录前言一、解析二、使用步骤1.引入库2.读入数据总结 前言 理解成为一个死循环 一、解析 # 去生成或获取一个事件循环 loop = asyncio.get_event_loop() # 将任务放到任务列表 loop.run_until_complete(asyncio.wait(tasks)) 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import
【Android 异步操作】AsyncTask 异步任务 ( AsyncTask 异步任务执行方法 execute 方法相关源码解析 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
07-10 2209
一、AsyncTask 异步任务执行方法 execute() 引入 二、AsyncTask 异步任务执行方法 execute() 三、sDefaultExecutor 线程池解析 四、executeOnExecutor 方法解析 五、AsyncTask 异步任务执行方法 execute() 相关源码注释
nodejs async
最新发布
02-14
Node.js中的异步编程是通过使用回调函数、Promise和async/await等方式来实现的。其中，async/await是一种相对简洁和易于理解的异步编程模型。 async/await是ES2017引入的一种语法糖，它基于Promise，并且使得异步代码看起来更像是同步代码。通过使用async关键字来定义一个异步函数，该函数内部可以使用await关键字来等待一个Promise对象的完成，并且可以像同步代码一样顺序执行。 下面是一个简单的示例，展示了如何使用async/await来处理异步操作： ```javascript async function fetchData() { try { const response = await fetch('https://api.example.com/data'); const data = await response.json(); console.log(data); } catch (error) { console.error(error); } } fetchData(); ``` 在上面的示例中，fetchData函数是一个异步函数，它使用await关键字等待fetch函数返回的Promise对象完成。然后，它使用await关键字等待response.json()方法返回的Promise对象完成。最后，它打印出获取到的数据或者捕获到的错误。 使用async/await可以使得异步代码更加可读和易于维护。但需要注意的是，async/await只能在支持ES2017语法的环境中使用，或者通过Babel等工具进行转译。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值