Async流程控制学习

作者: 2林子易2 | 来源:发表于2016-09-10 17:31 被阅读0次

Async流程控制学习
node 异步模式
08 - 异步流程控制
Async 异步方法区别
Async流程控制，支持oc链式语法
async 异步编程框架
async介绍
async流程控制函数
Async异步流程控制使用
Node流程控制库async

今天学习nodeJS深入浅出的第四章。
node异步控制有提到Async的强大流程控制能力，我觉得有必要学习下，所以去翻了Async的API。
作为一个英文渣渣，API的英文阅读实在不是一件很爽的事情，所以写下这篇文章作为我的Async中文的API.

Collections

Async集合处理函数格式
  async.xx(coll, function, callback);
  coll：Array|iteratee|Object
  iteratee：function//异步处理函数function(item, callback)
  callback

Async集合的返回必须都是callback返回！例如：
  async.concat(["1","2","3"], function(item, callback){
    callback(null,item);//在这里回调返回
  },function(err, values){
     console.log(values);//这里才可以获取到值
  });

基本每个函数都有Series串行方法和Limit并行方法的数量限制方法。
异步处理函数默认的参数列表：[obj,] value [,key], callback

each
eachOf
map
mapValues
concat
filter
reject
detect
every
some
reduce
reduceRight
sortBy
transform

这里函数用each或者forEach都可以

each对每个元素进行相同的处理，无返回。
eachSeries顺序执行异步处理函数。
eachLimit设置最大并行数。

<h4 id = "eachOf">forEachOf</h4>

eachOf区别于each之处在于异步处理函数有三个参数function(value, index,callback)

map与each相同都是对列表中每个元素进行处理，不过map有返回。
区别于concat，map的返回列表元素就是原来的列表元素数，不会改变数量，而concat可以改变数量。
mapSeries顺序执行异步处理函数。
mapLimit设置最大并行数。

<h4 id = "mapValues">mapValues</h4>

mapValues与map相同,不过mapValues是专门设计为Object。
它的异步处理函数function(value, key, callback)，可以处理key-value键值对。
mapValuesSeries顺序执行异步处理函数。
mapValuesLimit设置最大并行数。

<h4 id = "concat">concat</h4>

conat对列表每个元素进行处理并返回处理结果组成一个新的列表。
cancatSeries顺讯进行异步函数处理

<h4 id = "filter">filter</h4>

filter用于筛选符合条件的元素。callback返回必须为true OR false。
filterSeries顺序执行异步处理函数。
filterLimit设置最大并行数。

<h4 id = "reject">reject</h4>

reject和filter的行为正好相反，false时返回，true时丢弃。
rejectSeries顺序执行异步处理函数。
rejectLimit设置最大并行数。

<h4 id = "detect">detect</h4>

detect用于取得列表中第一个符合条件的元素。callback必须返回为true OR false。
detectSeries顺讯进行异步函数处理
detectLimit异步方式设置最大并行数，加到第一第二参数中间。

<h4 id = "every">every</h4>

这里函数用every或者all都可以

every用于判断所有元素是否满足条件，异步处理callback必须返回true OR false
everySeries顺序执行异步处理函数。
everyLimit设置最大并行数。

这里函数用some或者any都可以

some用于判断所有元素中是否有满足条件的，异步处理callback必须返回true OR false
someSeries顺序执行异步处理函数。
someLimit设置最大并行数。

<h4 id = "reduce">reduce</h4>

reduce给定一个初始值，用它和集合中的每个元素做运算，最后返回一个值。即初始值加上列表中所有的值。
顺序为从左到右
async.reduce(arr, memo, iterator(memo,item,callback), callback(err, result))
注意：reduce没有异步方式

<h4 id = "reduceRight">reduceRight</h4>

reduceRight不同于reduce的地方在于它的顺序是从右往左。

<h4 id = "sortBy">sortBy</h4>

sortBy对集合内的元素进行排序，依据每个元素进行某异步操作后产生的值，从小到大排序。

<h4 id = "transform">transform</h4>

transform有点像map，不过他可以对Object操作
数组：function (acc, item, index, callback)
集合：function (obj, val, key, callback)

Control Flow

对于JavaScript的异步大坑估计我们都不陌生，解决办法无非就是那三种。
  1. 事件监听
  2. Promise
  3. 流程控制
其实用的最多的还是Promise，不过Promise有个问题一直在困扰着我。
返回怎么才能返回一个正常的值而不是一个Promise对象。

Async以它的流程控制能力而著称，始终保持前三的地位！我继续学习。

applyEach
auto
autoInject
cargo
compose
whilst
forever

<h4 id = "applyEach">applyEach</h4>

applyEach(functions, …argsopt, callbackopt)
更加强大的each，将参数分别执行多个异步处理函数，类似于
async.each(…argsopt,async.applyEach([functions]),callback);
applyEachSeries同步执行方法

auto(tasks, concurrencyopt, callbackopt)
多个函数有依赖关系，有的并行执行，有的依次执行的情况
concurrencyopt为max number
返回一个JSON的处理列表
格式：
    functionname:function(callback){}//无依赖
    functionname:['依赖一','依赖二',...,function(callback){}]//存在依赖

<h4 id = "autoInject">autoInject</h4>

autoInject(tasks, callbackopt)
自动注入依赖
格式：
    functionname:function(依赖一,依赖二,...,callback){}

<h4 id = "cargo">cargo</h4>

一个串行的消息队列，类似于queue，通过限制了worker数量，不再一次性全部执行。
不同之处在于，cargo每次会加载满额的任务做为任务单元，只有任务单元中全部执行完成后， 才会加载新的任务单元。
http://caolan.github.io/async/docs.html#.cargo

<h4 id = "compose">compose</h4>

compose(…functions)
还记得回调地狱吗？
自动回调地狱模式，例如compose(a,b,c,d) = a(b(c(d())))

<h4 id = "whilst">whilst</h4>

whilst(test, iteratee, callbackopt)
异步模式的循环和同步的while语句相似
test相当于while语句的条件，return为false时停止
iteratee相当于while的执行块，通过callback返回
实例：
    var count = 0;
    async.whilst( 
        function() { return count < 5; }, //判断模块
        function(callback) { //迭代模块，通过callback返回
          count++;
          setTimeout(function() { 
            callback(null, count);
         }, 1000); 
      }, 
      function (err, n) { // 5 秒后, n = 5 }//若判断模块为false，这里才能收到callback
    );

这里until，During，doWhilst，doUntil，doDuring与whilst相似//其实是不想写了，api估计也这么想的

<h4 id = "forever">forever</h4>

<h4 id = "parallel">parallel</h4>

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

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

同时支持json形式的tasks，其最终callback的结果也为json形式。
有点像Promise.all()

parallelLimit(tasks, limit, callbackopt)限制最大并行数