node--异步模块

异步 node Async

高阶函数概念

参数可以是函数，返回值返回一个匿名函数

偏函数概念

根据参数定制函数

async 模块

github Async;

async.series()函数，顺序执行一组函数，参数类型是什么返回类型和参数类型一致（第一个参数可以是一个数组也可以是一个JSON对象）
串行执行

    async.series({
        one: function(callback){
            callback(null, 1);
        },
        two: function(callback){
            callback(null, 2);
        }
    },function(err, results) {
     console.log(results);
    });
//{ one: 1, two: 2 }


var async = require('async');
async.series({
  one:function(callback){
    callback(null,1);
  },
  two:function(callback){
    callback(null,2);
  }
},function(err,result){
console.log(result);
});
//[1,2]

async.waterfall(tasks,callback);
第一个参数必须是数组类型，顺序执行函数，将上一个函数的值传递给下一个函数

var async = require('async');
async.waterfall([function(callback){
  callback(null,1);
},function(data,callback){
  callback(null,data+2);
}],function(err,data){
  console.log(data);
});
//3

async.parallel(tasks,callback)每个函数都是立即执行（异步的并行执行）

4.parallelLimit(tasks, limit, [callback])

parallelLimit函数和parallel类似，但是它多了一个参数limit。 limit参数限制任务只能同时并发一定数量，而不是无限制并发，

5.whilst(test, fn, callback)

相当于while，但其中的异步调用将在完成后才会进行下一次循环。当你需要循环异步的操作的时候，它可以帮助你。

var count = 0;
async.whilst(
    function () { return count < 5; },//相当于if判读句
    function (callback) {
        count++; //执行函数
        setTimeout(callback, 1000);
    },
    function (err) {
 	//函数执行结束
    }
);

6.doWhilst(fn, test, callback)，类似do while

 var count = 0;
 async.doWhilst(
     function (callback) {
         count++;
         setTimeout(callback, 1000);
     },
     function () { return count < 5; },
     function (err) {
     console.log(err);
}

util 是和whilst 相反的，返回false 的时候执行函数，判断不成立的时候执行函数 (类似于while循环)
如果你需要异步循环
do util 类比上文

9.compose() 可以创建一个异步函数的集合函数，将传入的多个异步函数包含在其中，当我们执行这个集合函数时，会依次执行每一个异步函数，每个函数会消费上一次函数的返回值。


    var async=require("async");
	   function fn1(n, callback) {
        setTimeout(function () {
            callback(null, n + 1);
        }, 1000);
    }
    function fn2(n, callback) {
        setTimeout(function () {
            callback(null, n * 3);
        }, 1000);
    }
    var demo = async.compose(fn2, fn1);
    demo(4, function (err, result) {
    console.log("LL",result);
      
    });
//LL 15 先执行fn1,将fn1的结果传递给fn2

forever函数比较特殊，它的功能是无论条件如何，函数都一直循环执行，只有出现程序执行的过程中出现错误时循环才会停止，callback才会被调用。
自动依赖处理 async.auto() 方法

writeFile依赖getData和makeFolder,emailLink依赖writeFile。

 async.auto({
    getData: function(callback){
        callback(null, 'data', 'converted to array');
    },
    makeFolder: function(callback){        
        callback(null, 'folder');
    },
    writeFile: ['getData', 'makeFolder', function(callback, results){        
        callback(null, 'filename');
    }],
    emailLink: ['writeFile', function(callback, results){
        callback(null, {'file':results.writeFile, 'email':'user@example.com'});
    }]
}, function(err, results) {
    console.log('err = ', err);
    console.log('results = ', results);
});

11queue(worker, concurrency);

queue相当于一个加强版的parallel，主要是限制了worker数量，不再一次性全部执行。当worker数量不够用时，新加入的任务将会排队等候，直到有新的worker可用。

它有多个点可供回调，如无等候任务时(empty)、全部执行完时(drain)等。

示例：定义一个queue，其worker数量为2：

 var q = async.queue(function(task, callback) {
    console.log('worker is processing task: ', task.name);
    callback();
}, 2);
q.push({name: 'foo'}, function (err) {
    console.log('finished processing foo');
});
q.push({name: 'bar'}, function (err) {
    console.log('finished processing bar');
});
//当最后一个任务交给worker执行时，会调用empty函数:
q.empty = function() {
    console.log('no more tasks wating');
}

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

iterator(tasks)
将一组函数包装成为一个iterator，可通过next()得到以下一个函数为起点的新的iterator。

高阶函数 概念

偏函数 概念

async 模块

高阶函数概念

偏函数概念