nodejs异步调用async

犹豫nodejs是异步编程模型，有一些在同步编程中很容易做到的事情，现在却变得很麻烦，async的流程控制就是为了简化这些操作
var async = require('async');

1、series（多个函数一次执行，之间没有数据交换）
series(tasks,[callback])顺序执行数组、集合内的函数，当前面一个函数执行完成就会立即执行下一个函数，如果函数触发了错误，可以在callback函数中验证，否则会一直执行完成tasks
有多个异步函数需要依次调用，一个完成之后才能执行下一个，各函数之间没有数据的交换，仅仅需要保证其执行顺序，这时可以使用series。
tasks传的是一个数组函数

const async=require('async');
async.series([
    function(callback){
        console.log("one");
        callback(null,"one");
    },
    function(callback){
        console.log("two");
        callback(null,"two");
    }
],function(err,results){
    console.log("err======"+err);
    console.log("results======"+results);
    console.log("typeof results======"+typeof (results));
})

运行之后输出：

one
two
err======null
results======one,two
typeof results======object

我觉得这里很重要的是err是上面两个函数的错误信息，而results这个参数是一个数组对象，他们的值是上面数组函数每个callback里面的参数
以上代码详解：
　　1、依次执行一个函数数组中的每个函数，每一个函数执行完成之后才能执行下一个函数。
　　2、如果任何一个函数向它的回调函数中传了一个error，则后面的函数都不会被执行，并且将会立刻将该error以及已经执行了的函数的结果传给series中最后的那个callback
　　3、当所有的函数执行完后（没有出错）,则会把每个函数传给其回调函数的结果合并为一个数组，传递给series最后的那个callback。
　　4、还可以json的形式来提供tasks。每个属性都会被当作函数来执行，并且结果也会以json形式传给series最后那个callback，这种方式可读性更高一些。
　　5、如果中间某个函数出错，series函数如何处理：中间有函数出错。出错之后的函数不会执行，错误及之前正常执行的函数结果将传给最终的callback。
　　6、如果某个函数传给回调的值是undefined，null,{},[]等，series如何处理：如果某个函数传的数据是undefined, null, {}, []等，它们会原样传给最终callback。
　　7、另外还需要注意的是：多个series调用之间是不分先后的，因为series本身也是异步调用。
模拟series多个函数中一个出错会如何

const async=require('async');
async.series([
    function(callback){
        console.log("one");
        callback("error","one");
    },
    function(callback){
        console.log("two");
        callback(null,"two");
    }
],function(err,results){
    console.log("err======"+err);
    console.log("results======"+results);
    console.log("typeof results======"+typeof (results));
})
运行后输出：

　　one
　　err======error
　　results======one
　　typeof results======object

传json形式tasks

代码：

const async=require("async");

async.series({
    one:function(callback){
        setTimeout(function(){
            callback(null,1);
        },200)
    },
    two:function(callback){
        setTimeout(function(){
            callback(null,2);
        })
    }
},function(err,results){
    console.log("results0====="+results['one']);
    console.log("results1====="+results['two']);
})
运行后输出：

　　results0=====1
　　results1=====2

这是一个json格式的results

2、parallel

　　parallel(tasks,[callback])并行执行数组集合内的方法，不用等到前一个函数执行完再执行下一个函数，如果函数促发了错误，可以再callback函数中验证

　　并行执行多个函数，每个函数都是立即执行，不需要等待其它函数先执行。传给最终callback的数组中的数据按照tasks中声明的顺序，而不是执行完成的顺序。
　　

　　如果某个函数出错，则立刻将err和已经执行完的函数的结果值传给parallel最终的callback。其它未执行完的函数的值不会传到最终数据，但要占个位置。

　　同时支持json形式的tasks，其最终callback的结果也为json形式。

const async=require('async');

async.parallel([
    function(callback){
        setTimeout(function(){
            callback(null,"one");
        },200)
    },
    function(callback){
        setTimeout(function(){
            callback(null,"two");
        },100);
    }
],
function(err,results){
    console.log("err====="+err);
    console.log("results====="+results);
})
运行后输出：

err=====null
results=====one,two

代码：

const async=require('async');

async.parallel([
        function(callback){
            setTimeout(function(){
                callback(null,"one");
            },400)
        },
        function(callback){
            setTimeout(function(){
                callback("err","two");
            },200);
        },
        function(callback){
            setTimeout(function(){
                callback(null,"three");
            },100);
        }
    ],
    function(err,results){
        console.log("err====="+err);
        console.log("results====="+results);
    })
运行后输出：

err=====err
results=====,two,three

代码：

const async=require('async');

async.parallel({
        one:function(callback){
            setTimeout(function(){
                callback(null,"one");
            },400)
        },
        two:function(callback){
            setTimeout(function(){
                callback(null,"two");
            },200);
        },
        three:function(callback){
            setTimeout(function(){
                callback(null,"three");
            },100);
        }
},
    function(err,results){
        console.log("err====="+err);
        console.log("results====="+results['one']);
        console.log("results====="+results['two']);
        console.log("results====="+results['three']);
    })
运行后输出：

err=====null
results=====one
results=====two
results=====three

3、waterfall

waterfall(tasks,callback),多个函数依次执行，且前一个的输出为吼一个的输入，

与series相似，按顺序依次执行多个函数，不同之处是，每个函数产生的值，都将传给下一个函数，如果中途出错，后面的函数将不会被执行。错误信息以及之前产生的结果，将传给waterfall最终的callback;该函数不支持json格式的tasks，

* 注意，所有的callback都必须形如callback(err, result)，但err参数在前面各函数中无需声明，它被自动处理。

中途有函数出错，其err和产生的值将直接传给最终callback，后面的函数不再执行

代码：

const async=require('async');
async.waterfall([
    function(callback){
        callback(null,'one','two');
    },function(args,arg2,callback){
        callback(null,'three');
    },function(arg1,callback){
        callback(null,'done');
    }
],function(err,results){
    console.log("results====="+results);
})
运行后输出：
results=====done
代码：

const async=require('async');
async.waterfall([
    function(callback){
        callback(null,'one','two');
    },function(args,arg2,callback){
        callback("err",'three');
    },function(arg1,callback){
        callback(null,'done');
    }
],function(err,results){
    console.log("results====="+results);
})
运行后输出：

results=====three

4、whilst

whilst(test,fn,callback)，可用于异步调用的while，第一个参数为验证条件，第二个参数为执行函数，第三个参数为验证失败后回调函数，一般在延迟动画用的比较多

相当于while，但其中的异步调用将在完成后才会惊醒下一次循环，

代码：

const async=require('async');
var count=0;
async.whilst(
    function(){   //验证成功继续，失败回调
        return count<5;
    },
    function(callback){   //1秒过去该函数回调执行完毕，接着循环，知道count=5的时候，第一个方法过不去了，报错，走到第三个方法
        console.log("count"+count);
        count++;
        setTimeout(callback,1000);
    },
    function(err){
        console.log("err"+err);
    }
)
代码运行后输出：

count0
count1
count2
count3
count4
errnull

该函数的功能比较简单，条件变量通常定义在外面，可供每个函数访问，在循环中，异步调用时产生的值实际上被丢弃了，因为最后那个callback只能传入错误信息。

另外，第二个函数fn需要能接受一个函数cb，这个cd最终必须被执行，用于表示出错或正常结束

中途出错。出错后立刻调用第三个函数。

代码：

const async=require('async');
var count=0;
async.whilst(
    function(){   //验证成功继续，失败回调
        return count<5;
    },
    function(callback){   //5秒过去后
        console.log("count"+count);
        count++;
        if(count===1){
            callback("err");
        }else{
            setTimeout(callback,1000);
        }
    },
    function(err){
        console.log("err"+err);
    }
)
运行后输出：

count0
errerr

第二个函数即使产生值，也会被忽略。第三个函数只能得到err。

5、eachLimit

eachLimit(arr, limit, iterator, callback)批量遍历集合。同一时候只会执行limit个任务。遍历过程有异常通过cb返回，进程不会中断，直到全部遍历完成后err在最后的回调函数返回。

async.eachLimit([1, 2, 3, 4, 5, 6, 7, 8], 2, function(item, cb) {
    console.info(item);
    if (item == 4) {
        cb('throw err: ' + item);
    } else {
        cb();
    }
}, function(err) {
    console.info('catch err: ' + err);
});