Node.js异步控制流：回调、事件、Promise和async/await

前言

对于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 入门， 阮一峰