js中的async模块详解

Created by bugall on 15-3-14.
哪里有些错的地方还请大家帮忙指出,共同学习

收集功能部分：

each(arr,iterator,callback);

iterator: 迭代器(处理函数)

callback:each()的回调

我们假设openFiles是要打开的文件,saveFile是文件的处理函数

async.each(openFiles,function(file,callback){

})

---

async.each(openFiles,function(file,callback){

    console.log('Processing file' + file);

    if(file.length>32){
        console.log('this file name is too long');
        callback('File name too long');
    }else{
        console.log('File processed');
        callback();
    }
//下面这里是在迭代器函数处理完所有的openFiles里的所有参数后的each的回调
},function(err){
    //如果迭代器函数在处理任何一个openFiles时报错,都会调用each的回调
    if(err){
        console.log('not ok!');
    }else{
        console.log('file process done');
    }
});

 * 注意这里的迭代器在处理openFile中的函数式是批处理

---

eachSeries(arr, iterator, callback)

顾名思义,参数与each()一样,arr的含义相同,但是iterator在处理每一个arr的参数时是序列化(同步的),下一个
参数迭代器处理的前提是当前参数以被迭代器处理完成
通俗讲就是迭代器在处理arr参数时的顺序是按照

---

eachLimit(arr,limit,iterator,callback)

limit的意思是,无论什么时候迭代器iterator最多执行arr中参数的个数
async.eachLimit(documents, 20, requestApi, function(err){
    // documents中任何一个参数在requestApi迭代器中执行出错时，或是执行20个参数完毕
    // 注意: requestApi在执行documents参数时  并不是批处理
});

---

map(arr, iterator, callback)

参数看起来与each()的相同,但是功能刚好相反。
map的功能是把迭代器处理完成后的结果组合一个数组返回

async.map(['file1','file2','file3'], fs.stat, function(err, results){
    // result是一个stats集合,fs('file1'),fs('file2'),fs('file3')的结果集合
    // 注意这是并行的
});

---

mapSeries(arr, iterator, callback)
类似的map也有并行的实现方法

---

mapLimit(arr, limit, iterator, callback)

async.mapLimit(['file1','file2','file3'], 1, fs.stat, function(err, results){
    // results is now an array of stats for each file
});

限制执行参数的个数。注意不是批处理

---

filter(arr, iterator, callback)

化名:select
返回一个迭代器处理后的结果集,
特别的是iterator的返回值中只接受true,false。
不想map,each接受err,filter中不接受err的处理
通俗说filter中的回调函数结果集只有true,false

---

filterSeries(arr, iterator, callback)

---

reject(arr, iterator, callback)
这个与filter是对立的,这个只接受err的结果

---

rejectSeries(arr, iterator, callback)

---

reduce(arr,memo,iterator,callback)

async.reduce([1,2,3], 0, function(memo, item, callback){
    // 异步
    process.nextTick(function(){
        callback(null, memo + item)
    });
}, function(err, result){
    // result就是最后一个memo的值为6
});
这里从功能上看就是把1+2+3的结果输出,更像是递归调用
但是不同的是 这里是异步的。
初始时demo的值为0
第一次demo的值为0+1,
第二次demo的值为1+2,
第三次demo的值为3+3

---

reduceRight(arr, memo, iterator, callback)
功能与reduceRight()一样,但是计算数序是从arr的最后以为开始,倒序

---

detect(arr,iterator,callback)
只要有一个通过可行性验证就返回(true)
如果所有参数都没有通过验证就返回”undfined”
注意 这里是批处理

---

detectSeries(arr,iterator,callback)
只要通过可行性验证就返回(true)
但是这里是序列化 从左到右依次验证

---

sortBy(arr, iterator, callback)
对处理后的结果集合进行排序

例如:
//升序
    async.sortBy([1,9,3,5], function(x, callback){
        callback(null, x);
    }, function(err,result){
        //结果
    } );

//降序
async.sortBy([1,9,3,5], function(x, callback){
    callback(null, x*-1);
}, function(err,result){
    //结果
} );

---

async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files){
    // 结果列表
});
/**
 * 异步处理
 * {
 *  dir1: obj,
 *  dir3: obj,
 *  dir2: obj
 * }
 * 返回值是一个json对象
 * */

concatSeries(arr, iterator, callback)
/**
 * 同步
 * {
 *  dir1: obj,
 *  dir2: obj,
 *  dir3: obj
 * }
 * */

---

控制部分

---

series(tasks, [callback])

---

series(tasks, [callback])
async.series([
        function(callback){
            callback(null, 'one');
        },
        function(callback){
            callback(null, 'two');
        }
    ],
    function(err, results){
        // results: ['one', 'two']
    });

// 以对象的形式
async.series({
        one: function(callback){
            setTimeout(function(){
                callback(null, 1);
            }, 200);
        },
        two: function(callback){
            setTimeout(function(){
                callback(null, 2);
            }, 100);
        }
    },
    function(err, results) {
        // results: {one: 1, two: 2}
    });

/**
 * 这里的执行顺序是同步的
 * */

---

parallel(tasks, [callback])

---

/**
 * 并行，异步执行
 * */
async.parallel([
        function(callback){
            setTimeout(function(){
                callback(null, 'one');
            }, 200);
        },
        function(callback){
            setTimeout(function(){
                callback(null, 'two');
            }, 100);
        }
    ],
    function(err, results){
        // results: ['one','two'] ,尽管这里异步，但是必须要等到所有函数执行完才会执行回调
    });

async.parallel({
        one: function(callback){
            setTimeout(function(){
                callback(null, 1);
            }, 200);
        },
        two: function(callback){
            setTimeout(function(){
                callback(null, 2);
            }, 100);
        }
    },
    function(err, results) {
        // results: {one: 1, two: 2}
    });

---

在这里着重讲解下async.auto(tasks,[callback])

---

router.get('/', function(req, res) {
    async.auto({
        func1: function (callback, results) {
            console.log('first');
            callback(null, "abc", "bbc");
        },

        func2: function (callback, results) {
            console.log("Print#1:\n",results);
            callback(null, { "puncha": "during" });
        },
        func3: ["func2", function (callback, results) {
            console.log("Print#2:\n",results);
            callback(null, 3);
        }],
        func4: ["func1", "func3", function (callback, results) {
            console.log("Print#3:\n",results);
            callback(null);
        }]
    },function(err,result){
        console.log(err,'final error');
    });
    res.render('ceshi', { title: 'Express' });
});

 看一下输出内容
 first
 Print#1:
 { func1: [ 'abc', 'bbc' ] }
 Print#2:
 { func1: [ 'abc', 'bbc' ], func2: { puncha: 'during' } }
 Print#3:
 { func1: [ 'abc', 'bbc' ],
  func2: { puncha: 'during' },
  func3: 3
 }
 这里需要注意的是对于func1的callback(),虽然里面有三个参数,其实可以看成
 callback(null,obj)  obj=['abc','bbc']
 如果null参数不为‘null’ 则敢函数和跟此函数有依赖的函数都将不会被执行例如：
first
Print#1:
{}
Print#2:
{ func2: { puncha: 'during' } }