最近在学习nodejs，这两天学习了异步非同步(异步)模块这个地方知识点挺多的，所以，今天添加一点小笔记。

异步非同步(异步)模块是为了解决嵌套金字塔，和异步流程控制而生。常用的方法介绍

国家预防机制安装好异步非同步(异步)模块，然后引入就可以使用var async=require(' async ')；

1.系列（任务，[回调])

多个函数从上到下依次执行，相互之间没有数据交互

var task1=函数（回调){控制台。日志(“任务1”)；回调(null，“任务1”)} var任务2=函数(回调){控制台。日志(“任务2”)；回调(null，“任务2”)} var任务3=函数(回调){控制台。日志(“任务3”)；回调(null，“task 3”)} async . series([task 1，task2，task3]，function(err，result){ console。日志('系列')；if(err){ console。日志(err)；} console.log(结果);}) 运行结果：

如果中途发生错误，则将错误传递到回调函数，并停止执行后面的函数

var task1=函数（回调){控制台。日志(“任务1”)；回调(null，“任务1”)} var任务2=函数(回调){控制台。日志(“任务2”)；回调(“err”、“task 2”)} var task 3=function(回调){控制台。日志(“任务3”)；回调(null，“task 3”)} async . series([task 1，task2，task3]，function(err，result){ console。日志('系列')；if(err){ console。日志(err)；} console.log(结果);}) 运行结果：

2 .并行（任务，[回调])

多个函数并行执行，不会等待其他函数

var task1=函数（回调){控制台。日志(“任务1”)；setTimeout(function(){ callback(null，' task1') }，5000)；} var task2=函数(回调){控制台。日志(“任务2”)；setTimeout(function(){ callback(null，' task2') }，1000)；} var task3=函数（回调){控制台。日志(“任务3”)；setTimeout(function(){ callback(null，' task3') }，3000)；} console.time('并行方法');async.parallel([task1，task2，task3]，function(err，result){ console。log(' parallel ')；if(err){ console。日志(err)；} console.log(结果);console.timeEnd('并行方法');}) 运行结果：

3个函数分别延迟5000毫秒、1000毫秒、3000毫秒结果5000毫秒就执行完毕。

如果中途出错，则立即将犯罪和值传到最终的回调函数，其他未执行完毕的函数将不再执行，但是要占一个位置

var task1=函数（回调){控制台。日志(“任务1”)；setTimeout(function(){ callback(null，' task1') }，5000)；} var task2=函数(回调){控制台。日志(“任务2”)；setTimeout(function(){ callback(' err message '，' task2') }，3000)；} var task3=函数（回调){控制台。日志(“任务3”)；setTimeout(function(){ callback(null，' task3') }，1000)；} console.time('并行方法');async.parallel([task1，task2，task3]，function(err，result){ console。log(' parallel ')；if(err){ console。日志(err)；} console.log(结果);console.timeEnd('并行方法');}) 运行结果：

3 .瀑布（任务，[回调]) :瀑布流

依次执行，前一个函数的输出为后一个函数的输入

var task1=函数（回调){控制台。日志(“任务1”)；回调(null，' 11') } var task2=function(q，callback){ console。日志(“任务2”)；console.log('task1函数传入的值： ' q)；回调(null，' 22') } var task3=function(q，callback){ console。日志(“任务3”)；console.log('task2函数传入的值： ' q)；回调(null，' 33') } console.time('瀑布方法');异步。瀑布([任务1，任务2，任务3]，函数(错误，结果){ console.log('瀑布');if(err){ console。日志(err)；} console.log('结果： '结果);console.timeEnd('瀑布方法');}) 执行结果：

如果中途出现错误，后面的函数将不在执行，之前执行的结果和错误信息将直接传到最终的回调函数

var task1=函数（回调){控制台。日志(“任务1”)；回调(null，' 11') } var task2=function(q，callback){ console。日志(“任务2”)；console.log('task1函数传入的值： ' q)；回调(' errmessage '，' 22') } var task3=function(q，回调){ console。日志(“任务3”)；console.log('task2函数传入的值： ' q)；回调(null，' 33') } console.time('瀑布方法');异步。瀑布([任务1，任务2，任务3]，函数(错误，结果){ console.log('瀑布');if(err){ console。日志(err)；} console.log('结果： '结果);console.timeEnd('瀑布方法');}) 运行结果：

4 .并行限制（任务、限制、[回调])

和平行的类似，只是限制参数限制了同时并发执行的个数，不再是无限并发

var task1=函数（回调){控制台。日志(“任务1”)；setTimeout(function(){ callback(null，' task1') }，5000)；} var task2=函数(回调){控制台。日志(“任务2”)；setTimeout(function(){ callback(null，' task2') }，3000)；} var task3=函数（回调){控制台。日志(“任务3”)；setTimeout(function(){ callback(null，' task3') }，4000)；} console.time('parallelLimit方法');async.parallelLimit([task1，task2，task3]，2，函数(err，result){ console。log(‘平行极限’)；if(err){ console。日志(err)；} console.log(结果);console.timeEnd('parallelLimit方法');}) 运行结果：

三个函数分别是延迟5000毫秒、3000毫秒、4000毫秒结果执行时间为什么是7000毫秒呢

因为首先执行函数一和2,

3秒后函数2执行完毕，这个时候函数3开始执行，

5秒后函数一执行完毕，函数3还有2秒，

七秒后函数3执行完毕。

5 .自动（任务，[回调])

多个函数有数据交互，有的并行，有的依次执行

console.time('auto方法');async.auto({ task1:函数（回调){控制台。log(' TSA k1 ')；setTimeout(function(){ callback(null，' task11 '，' task 12 ')；},2000);}，task2:函数（回调){控制台。日志(“任务2”)；setTimeout(函数(){回调(null，‘任务2’))；},3000);}，task3: ['task1 '，' task2 '，函数（回调，结果){控制台。日志(“任务3”)；console.log('task1和任务2运行结果' : ',结果);setTimeout(函数(){回调(null，‘任务3’))；},1000);}]，task4: ['task3 '，函数（回调，结果){控制台。日志(“任务4”)；console.log('任务1,任务2,任务3运行结果' : ',结果);setTimeout(function(){ callback(null，{'task41':results.task3，' task 42 ' : ' task 42 ' })；},1000);}] },函数(err，results) { console.log('err : '，err)；console.log('最终结果： ',结果);console.timeEnd('auto方法');});运行结果：

5秒运行完毕，

函数一和2并行，3秒执行完毕，

函数一和2执行完毕后，函数3,4依次执行共计5秒。

6 .而(测试，fn，[回调])

相当于正在…循环，fn函数里不管是同步还是异步都会执行完上一次循环才会执行下一次循环，对异步循环很有帮助，测试是条件，为真实的时执行【数学】函数里的方法

var datalist=[{number:10}，{number:20}，{number:30}，{number:40}，{ number :50 }]；定义变量计数=0;var test=function(){ return count datalist。长度；};var fn=函数(回调){ console.log(datalist[count]).数量);setTimeout(函数(){计数回调();},1000) };异步。while(test，fn，function(err){ if(err){ console。日志(err)；}控制台。日志(' while结束');});运行结果：

7.doWhilst

和当…的时候类似，和边做边看一个意思，首先执行一次fn，再判断，和当…的时候相比它把【数学】函数和试验位置交换了而已。

直到和当…的时候相反，当试验判断为错误的的时候执行【数学】函数里的方法，为真实的时跳出，

doUntil与doWhilst相反。

8 .永远(fn，errback)

永远就是无限循环了。只有当中途出现错误的时候才会停止

定义变量计数=0;async.forever(函数（回调){ console.log(计数);计数；if(计数10){回调(' err message ')；返回；} setTimeout(函数(){回调()；},1000) },函数(错误){控制台。日志(err)；});运行结果：

9 .撰写(fn1、fn2、fn3.)

这个方法会创建一个异步的集合函数，执行的顺序是倒序。前一个【数学】函数的输出是后一个【数学】函数的输入。有数据交互

var task1=函数(m，回调){控制台。日志(“任务1”)；setTimeout(function(){ callback(null，m*2) }，1000)；} var task2=function(m，回调){ console。日志(“任务2”)；settimeout(function(){ callback(null，m ^ 3)}，1000)；} var task3=function(m，回调){ console。日志(“任务3”)；setTimeout(function(){ callback(null，m*5) }，1000)；} console.time('撰写方法');var com=async.compose(任务3、任务2、任务1)；com(2，函数(错误，结果){ if(错误){ console。日志(err)；} console.log(结果);console.timeEnd('撰写方法');}) 运行结果：

相当于var m=2；(m * 2 ^ 3)* 5=35；

在我的项目开发中瀑布用的最多。

更多方法详情： https://www.npmjs.com/package/async

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我们。