async解决异步IO回调困扰 - 串行 - 并行方法简介

由于node.js的异步io,事件驱动回调等特性,导致大部分刚刚接触node.js的工程师每天困扰在多函数嵌套,异步执行顺序等问题上. 所以async 作为大名鼎鼎的异步控制流程包,在npmjs.org 排名稳居前五,目前已经逐渐形成node.js下控制异步流程的一个规范.async成为异步编码流程控制的老大哥绝非偶然,它不仅使用方便,文档完善,把你杂乱无章的代码结构化,生辰嵌套的回掉清晰化. async 提供的api包括三个部分:

(1)流程控制常见的几种流程控制.

(2)集合处理异步操作处理集合中的数据.

(3)工具类 .

github 开源地址:https://github.com/caolan/async 安装方法: npm install async 使用方法: var async=require('async');

串行且无关联

话句话说就是按照顺序执行,一个一个来,无关联就是值前一个callback回来的值不是后一步执行的条件场景:提取某学校大三学生的学生信息(假设每个班级存储在一个独立的数据表里) 分析:每个班级的学生之间是无关联的,假设共有3个班级,我们需要遍历3个表,把提取出的学生信息返回客户端一个json,如下

{
"1班":[{name:"张三",age:"21",class:"1班"},......(省略N个学生)]
"2班":[{name:"李四",age:"22",class:"2班"},......(省略N个学生)]
"3班":[{name:"王五",age:"22",class:"3班"},......(省略N个学生)]
}

如果不使用 async ,你也许只好挣扎在一堆大括号中

var class=require('./module/class');
export.pageStudent=function(req,res){
var rtnJson={};
    class.getStudent('1班',function(error,oneResult){
        if(!error&&oneResult){
            rtnJson['1班']=oneResult;
            class.getStudent('2班',function(error,twoResult){
                if(!error&&twoResult){
                    rtnJson['2班']=twoResult;
                    class.getStudent('3班',function(error,threeResult){
                        if(!error&&threeResult){
                            rtnJson['3班']=threeResult;
                            //3个班级全部获取完成
                            res.render('./veiw/pageStudent',{students:rtnJson});
                        }else{
                            res.render('./veiw/pageStudent',{students:rtnJson});
                        }
                    });
                }else{
                    res.render('./veiw/pageStudent',{students:rtnJson});
                }
            });
        }else{
            res.render('./veiw/pageStudent',{students:rtnJson});
        }
    });
}

看上去是不是很想吐的感觉?? 如果更多的班级出现,你用上面的方法估计会让你七窍流血,晕死在电脑桌前, 先了解一下async串行无关联方法

async.series({
  flag1:function(done){ //flag1 是一个流程标识,用户自定义
      //逻辑处理
      done(null,返回结果)// 第一个参数是异常错误,第二个参数的返回结果
  },
  flag2:function(done){
      //逻辑处理
      done('error info',null) //如果返回错误信息,
                              //下面的流程控制将会被中断,直接跳到最后结果函数
  },
},function(error,result){
    //最后结果
    //result是返回结果总集,包含了所有的流程控制 ,
    //result.flag1 可以获取标识1中处理的结果
});

对照上面的注释说明了解一下,然后我们把上面一大堆回调大括号的代码用async series方法改进一下

async.series({
    oneClass:function(done){
        class.getStudent('1班',function(error,oneResult){
            if(!error)
                done(null,oneResult);
            else
                done(error,null);
        });
    },
    twoClass:function(done){
        class.getStudent('2班',function(error,twoResult){
            if(!error)
                done(null,twoResult);
            else
                done(error,null);
        }
    },
    threeClass:function(done){
        class.getStudent('3班',function(error,threeResult){
            if(!error)
                done(null,threeResult);
            else
                done(error,null);
        }
    }
},function(error,result){
    if(!error)
        callback(null,result);
    else
        callback(error,null);
});

上面是一个标准的串行流程,代码可读性很强, 容易维护,但是这种流程只适合按顺序执行且每一步没有关联如果你的业务逻辑是根本不需要按顺序执行的,比如获取不同班级的信息,其实先获取1班和先获取3班是一样的,只要最后结果保证3个班的人员信息都获取成功即可.所以这里用series 是一种错误,反而和 node.js 的异步IO相互矛盾.应该用并行且无关联的控制流程. 串行无关联模式要求每一步执行成功后才能执行下一步流程.

并行且无关联

场景如上,获取4个班级学生信息. async 里的提供的并行无关联 api 是 parallel parallel 的原理是同时并行处理每一个流程,最后汇总结果,如果某一个流程出错就退出.把获取班级成员信息的代码用 parallel 来实现如下

async.parallel({
    oneClass:function(done){
        class.getStudent('1班',function(error,oneResult){
            if(!error)
                done(null,oneResult);
            else
                done(error,null);
        });
    },
    twoClass:function(done){
        class.getStudent('2班',function(error,twoResult){
            if(!error)
                done(null,twoResult);
            else
                done(error,null);
        }
    },
    threeClass:function(done){
        class.getStudent('3班',function(error,threeResult){
            if(!error)
                done(null,threeResult);
            else
                done(error,null);
        }
    }
},function(error,result){
    if(!error)
        callback(null,result);
    else
        callback(error,null);
});

看上去并行和串行仅仅是一个关键词的变化,其实他们的运行机制完全不同,并行无关联是全部业务流程一起进行,最后一个执行完直接返回结果,而不像上面的串行方法必须一个一个等待执行.

串行且有关联

场景:打开微博首页需要加载微博个人信息,微博分组信息,微博分组粉丝信息这里不考虑ajax 异步拉取每个模块.如果我们用ejs来渲染,需要发送给前端页面一个这样的数据结构(简单的模拟数据)

{
userInfo:{userID:10001,totalNum:368,fans:562,follow:369}
group:[{groupID:100,groupName:"粉丝"},{groupID:200,groupName:"同事"}...],
fansGroup:{"粉丝":[{nickName:'aa',age:20},{nickName:'bb',age:22}....]}
}

上面的信息取自3个不同的表,但是每一个流程都和上一个流程有关系,也就是说,如果拿到用户信息后,根据用户ID 获取此微博用户的分组,根据分组ID获取每个组里面的粉丝.一环扣一环,希望流程按顺序执行,且每一步逻辑控制都能由上一步得到的结果来做条件. 再来个传统的嵌套 ^_^

var userInfo=require('./lib/module/userInfo');
var group=require('./lib/module/group');
var groupFans=require('./lib/module/groupFans');
//传统嵌套代码如下
export.pageIndex=function(req,res){
    userInfo.get(userEmail,passWord,function(error,userInfo){
         group.get(userInfo.userID,function(error,groupList){
             var idx=0,fansList=[];
             for(var i=0;i<groupList.length;i++){
                 groupFans.get(groupList[idx++],function(error,fansInfo){
                     fansList.push(fansInfo);
                     if(idx==groupList.length){
                         callback(null,{userInfo:userInfo,group:groupList,fansGroup:fansList});
                     }
                 })
             }    
         });
    });
}

上面的代码互相牵扯关系,每一步的逻辑运算都需要上一步的结果来支持,我们假设每一步都运行正确,没有对error 进行判断. 最后因为要遍历数组中元素,然后把每个元素对应的分组成员都组合起来,我们用到了数据索引计数器 idx,上面的代码看似没有问题,但是索引计数器非常不好控制,稍有差错可能会不运行. anync 的waterfall 适合上面的场景. waterfall 每一步执行时需要由上一步执行的结果当做参数.所以每一步必须串行等待.事例代码如下:

console.time('waterfall');
async.waterfall([
    function (done) {
        done(null, 'one');
    },
    function (onearg, done) {
        done(null, onearg + '| two');
    },
    function (twoarg, done) {

        done(null, twoarg + '| three');
    },
    function (threearg, done) {
        done(null, threearg + '| four');
    }
], function (error, result) {
    console.log(result);
    console.timeEnd('waterfall');
})

上面调用 waterfall 函数时传入一个数组,数组总的每一个元素就是一个串行控制节点,每一个节点执行必须保证上一节点已经执行完成且拿到结果.这样将结果传入下一个控制节点作为参数来运行. 参数数组第一个元素回调函数 done(null,‘one’) -->null 说明执行没有错误, ‘one’ 是第一个节点运行返回的结果(这个结果将会传入第二个控制流程来作为参数)…这样以此类推,最后一个元素(第四个)返回的结果应该是 'one|tow|three|four ’ 这个字符串,也就是 result 打印出的内容.

注意

async 提供的api默认支持多种传递参数的写法,我个人比较喜欢用对象表示法来传递( json格式) 但是waterfall 这个api很特殊,不支持对象参数,如果你用下面的错误代码来调用 waterfall 的话,你不会拿到运行结果.

//此调用方法是错误的!!!
console.time('waterfall');
async.waterfall({
    one: function (done) {
        //处理逻辑
        done(null, 'one');
    },
    two: function (onearg, done) {
        //处理逻辑
        console.log('-----', onearg);
        done(null, onearg + 'two');
    },
    three: function (twoarg, done) {
        //处理逻辑
        done(null, twoarg + 'three');
    },
    four: function (threearg, done) {
        //处理逻辑
        done(null, threearg + 'four');
    }
}, function (error, result) {
    console.log(result);
    console.timeEnd('waterfall');
})

注意上面是错误的写法,waterfall 很特殊,不支持这样的写法,只能用上面数组传递参数的形式.

还有很多要介绍的,后续再补吧,祝大家周末愉快!

zzhi191 1楼•10 年前作者

惯例,自己坐沙发!

oubushixb 2楼•10 年前

之前也是在用async…如今转战bluebird了.

i5ting 3楼•10 年前

@oubushixb 我也是，bluebird太爽了

zzhi191 4楼•10 年前作者

@oubushixb 好,我也去围观下,多谢!

cool-l 5楼•10 年前

国产Thenjs比async好用

borisyu 6楼•10 年前

如果每一个流程里面，都涉及超过两个回调的话，那也得继续在async里嵌套async。除非把每一个步骤细分到不可分割的程度，这样流程就写得很长了。个人认为回调的感觉还是会存在的，只不过形式上更易于人去阅读。毕竟node的精髓就是异步，这一定会贯穿整个node应用的

LL101SS 7楼•10 年前

async.parallel([
    function(callback){
        setTimeout(function(){
            callback(null, 'one');
        }, 200);
    },
    function(callback){
        setTimeout(function(){
            callback(null, 'two');
        }, 100);
    }
],
// optional callback
function(err, results){
    // the results array will equal ['one','two'] even though
    // the second function had a shorter timeout.
});

@zzhi191 parallel 并行第二个是100ms，应该快一点，为什么结果不是［’tow‘，’one‘］？？