前言
对于Node.js的异步控制流，目前共计有四种常用的方式。较为经典的为callback和EventEmitter；在ES6中，加入了Promise；在ES7中加入了async/await。下面就逐个分析一下这四种常用的异步控制。
callback形式的异步控制
对于callback形式，即采用回调函数。在理解上，就是函数将任务分配出去，当任务完成之后，然后根据执行结果来进行相应的回调。可以看下面一个例子：
function sleep(ms, callback){
setTimeout(function(){
callback("finish") //执行完之后，返回‘finish’。
}, ms);
}
sleep(1000, function(val){
console.log(val);
});
//输出结果：finish。
这种形式十分容易理解，但是能够解决大部分的问题。但是却存在着致命的缺点。可以想象，如果需要在一段代码中调用多次sleep()函数，将会出现下面的情况：
var i = 0;//记录sleep()函数调用的次数
function sleep(ms, callback){
setTimeout(function(){
if(i < 2){
i++;
callback("finish", null);
}else{
callback(null, new Error('i大于2'));
}
}, ms);
}
//第一次调用
sleep(1000, function (val, err) {
if (err) console.log(err.message);
else {
console.log(val);
//第二次调用
sleep(1000, function (val, err) {
if (err) console.log(err.message);
else {
console.log(val);
//第三次调用
sleep(1000, function (val, err) {
if (err) console.log(err.message);
else {
console.log(val);
}
});
}
});
}
});
//输出结果分别为：finish，finish，i大于2。
由上面的例子可以看出，假如需要多次调用sleep()函数时，就会进行多次的嵌套。这种嵌套虽然可以使用，但是在代码的阅读、维护和美观上面，都是反人类出现的。所以，在新标准ES6和ES7发布之后，将会逐渐摒弃这种写法。
事件监听形式的异步控制
对于callback的改进就是使用事件监听的形式进行操作：每次调用异步函数都会返回一个EvetEmitter对象。在函数内部，可以根据需求来触发不同的事件。对不同的事件进行监听，然后做出相应的处理。具体代码如下：
var i = 0;
var events = require('events');
var emitter = new events.EventEmitter();//创建事件监听器的一个对象
function sleep(ms) {
setTimeout(function () {
i++;
if (i < 2) {
emitter.emit('done', 'finish');//触发事件'done'
} else {
emitter.emit('error', new Error('i大于2'));//触发事件'error'
}
}, ms);
}
var emit = sleep(1000);
//监听事件'done'
emitter.on('done', function(val){
console.log(val);
});
//监听事件'error'
emitter.on('error', function(val){
console.log(val);
});
通过事件监听的形式进行异步处理，可以更加直观和多样性。但是和callback类似，并没有解决嵌套的问题。例如需要调用多次sleep()函数，依然需要在函数emitter.on('done', function(val))中进行嵌套。
Promise对象进行异步控制处理
比较Promise和EventEmitter，可以发现两个十分明显的区别。对于EventEmitter，我们可以根据自己的需求来定义多种监听事件，然后对不同的事件进行不同的处理；对于promise，则可以对将异步操作的结果进行返回，然后根据返回值来进行相应的操作。对于promise的详细学习，可以通过在MDN查阅详细且最新的资料。
代码如下：
let num = 1
function sleep(ms) {
//返回一个Promise对象
return new Promise(function (resolev, reject) {
setTimeout(function () {
if (num < 1) {
num++
//如果成功，对resolve处理
resolev(new Error('finish'))
} else {
//如果失败，对reject操作
reject('i大于2')
}
}, ms)
})
}
sleep(300).then(value => {
console.log(value)
return sleep(300)
}).then(value => {
console.log(value)
return sleep(300)
}).then(value => {
console.log(value)
return sleep(300)
}).catch(function (error) {
console.log(error)
})
和callback与EventEmmitter相比，Promise将异步处理的嵌套函数进行了展开，更利于阅读和理解。当promise链中的任意一个函数出错都会直接抛出到链的最底部，所以我们统一用了一个catch去捕获，每次promise的回调返回一个promise，这个promise把下一个then当作自己的回调函数，并在resolve之后执行，或在reject后被catch出来。
async/await解决异步控制
虽然Promise将嵌套函数进行了展开，但是依然是链式函数，并没有解决回调本身。因此在最新的ES7中，引入了async/await函数，来解决这个问题。async函数返回一个 Promise 对象，可以使用then方法添加回调函数。当函数执行的时候，一旦遇到await就会先返回，等到异步操作完成，再接着执行函数体内后面的语句。
代码如下：
let num = 1
function sleep(ms) {
//返回一个Promise对象
return new Promise(function (resolev, reject) {
setTimeout(function () {
if (num < 3) {
num++
//如果成功，对resolve处理
resolev('finish')
} else {
//如果失败，对reject操作
reject(new Error('i大于2'))
}
}, ms)
})
}
//用关键词async修饰函数
async function asyncSleep() {
try {
let value
//用await来修饰函数
value = await sleep(300)
console.log(value)
value = await sleep(300)
console.log(value)
value = await sleep(300)
console.log(value)
} catch (error) {
console.log(error)
}
}
//调用函数
asyncSleep()
在上面的函数中，我们进行逐步分析
- 我们首先将
setTimeout函数进行封装，让其返回Promise对象。 - 然后声明一个用
async修饰的函数，在里面调用sleep()函数。 - 对于每次
sleep()函数，我们用await关键词进行修饰，表示下面的操作需要进行异步处理。 - 声明一个value变量来接受
sleep()函数返回的Promise对象。 - 最后用catch来对异常进行处理。
总的来说async/await是promise的语法糖，但它能将原本异步的代码写成同步的形式，try...catch也是比较友好的捕获异常的方式所以在今后写node的时候尽量多用promise或者async/await，对于回调就不要使用了，大量嵌套真的很反人类。
参考资料
node.js异步控制流程 回调，事件，promise和async/await
ECMAScript 6 入门， 阮一峰