Async:对比学习waterfall和series的用法

实例

目的：删除blog表的同时对应查找出的comment\reply也删除，如若没有直接删除blog

两种方法测试都是成功的

del:function (_id,req,res,next) {
async.waterfall([
function(callback){
//先从外到里查询，再从里到外依次删除
//根据blog_id查询comment(_id),查询的
model.Comment_getsByQuery({'blog_id':_id},{'_id':1},{ sort: {"time.create": -1}},function (err,comment) {
if (err || !comment) {
console.log('comment不存在');
callback(null);
} else {
//把这个数组转化为[id,id,id] 这种格式
for (var i = 0; i < comment.length; i++) {
var a = comment[i];
CommentAction.del(a._id, req, res, next);//根据comment_id删除comment和reply
console.log('删除comment以及对应的回复reply');
}
callback(null);
}
});
},
function () {;
//删除blog
model.Blog_removeByQuery({_id:_id},function (err,blog) {
if(err||!blog){
console.log(err);
res.send(406,{
err_name: "错误",
err_msg: "文章不存在"
});
}else{
res.send('删除blog成功');
console.log('删除blog')
}
})
}
], function (err, result) {
console.log(err);
console.log(result);
});
},

 

del:function (_id,req,res,next) {
async.series([
function(callback){
//先从外到里查询，再从里到外依次删除
//根据blog_id查询comment(_id),查询的
model.Comment_getsByQuery({'blog_id':_id},{'_id':1},{ sort: {"time.create": -1}},function (err,comment) {
if (err || !comment) {
console.log('comment不存在');
callback(null);
} else {
//把这个数组转化为[id,id,id] 这种格式
for (var i = 0; i < comment.length; i++) {
var a = comment[i];
CommentAction.del(a._id, req, res, next);//根据comment_id删除comment和reply
console.log('删除comment以及对应的回复reply');
}
callback(null);
}
});
},
function () {;
//删除blog
model.Blog_removeByQuery({_id:_id},function (err,blog) {
if(err||!blog){
console.log(err);
res.send(406,{
err_name: "错误",
err_msg: "文章不存在"
});
callback(null);
}else{
res.send('删除blog成功');
console.log('删除blog')
callback(null);
}
})
}
], function (err, result) {
console.log(err);
console.log(result);
});
},

 

 

1. series(tasks, [callback]) （多个函数依次执行，之间没有数据交换）

有多个异步函数需要依次调用，一个完成之后才能执行下一个。各函数之间没有数据的交换，仅仅需要保证其执行顺序。这时可使用series。

2. waterfall(tasks, [callback]) （多个函数依次执行，且前一个的输出为后一个的输入）

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

这个函数名为waterfall(瀑布)，可以想像瀑布从上到下，中途冲过一层层突起的石头。注意，该函数不支持json格式的tasks。

(摘自：http://blog.csdn.net/ctbinzi/article/details/39895401)

 

 

node.js 之async.js 里waterfall模块样例

（摘自：http://blog.csdn.net/youyudehexie/article/details/8274833）

//callback返回的第一个参数是err 后面的参数在下面的方法会调用
var async = require('async');
async.waterfall([
function(callback){
//这个括号中的程序依旧是异步的
console.log('1');
callback(null, 'one', 'two');
//回调函数一般放末尾
},
function(arg1, arg2, callback){
callback(null, 'three');
console.log(arg1);
console.log(arg2);
},
function(arg1, callback){
callback(null, 'done');
console.log(arg1);
}
], function (err, result) {
console.log(result);
});

运行结果：

1

done

three

one

two

 

 

（摘自：https://cnodejs.org/topic/53d3938d895ba3062b7f4509）

首先看waterfall，顾名思义，像流水线一样有序执行：

async.waterfall([
function (callback) {
var a = 5;
console.log('OK1');
setTimeout(function () {
callback(null, a * 2)
}, 1000);
},
function (data, callback) {
console.log('OK2');
setTimeout(function () {
callback(null, data + 7, data)
}, 2000);
},
function (result1, result2, callback) {
console.log('OK3');
setTimeout(function () {
callback(null, result1 - 9, result2)
}, 3000);
}
], function (err, kk, jj) {
console.log(kk);
console.log(jj);
})

格式为async.waterfall( [], finalFunction),将异步函数作为数组元素放进去，然后会按顺序执行，即使他是异步函数，也会等他把所有的操作完成后才会执行下一个函数，由上面的例子可以看出，数组里面的每一个函数都有一个callback回调函数，他们并不是指代同一个函数，而是下一个将要执行的函数，所以第一个函数的callback就是他后面的那个函数，自然数组最后一个函数的callback是finalFunction，对应递归写法的callback。除了这点还有一点需要注意，callback的第一个参数表示错误的信息，即使没错误，也要填上null，后面才是你想要传递的数据，而且除了finalFunction都不能显示接收错误信息，虽然callback有显式传递，waterfall的运行机制是只要数组中的任意一个函数出错立马跳到finalFunction，finalFunction会接收错误信息

再看async.series([],finalfunction(err,data));

async.series([
function (callback) {
setTimeout(function () {
callback(null, [1, 2])
}, 2000)
},
function (callback) {
setTimeout(function () {
callback(null, ['OK', 'hello'])
}, 3000)
}],
function (err, result) {
console.log(result);
}
);

与waterfall的不同点是，每一个函数执行的结果不是传递到下一个函数中，也就是说callback都是指代finalFunction,而且要显式传递错误信息， 每一个函数的执行结果都会有序保存到一个数组中，而finalFunction的第二个参数就会接收这个数组。可见这个处理的异步场景与waterfall不同，waterfall数组里面的后一个函数依赖于前一个函数的执行结果，而series则不。另外series可以将异步函数放在对象里，不一定是数组比如:

async.series({string:function(callback){…},number:function(callback){…}},finalFunction(err,data){…}),这样的话data接收的就是一个对象