在nodejs开发中，异常处理十分麻烦。一下代码捕捉不到错误
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| function async_error() {
setTimeout(function(){
throw new Error("Error");
},10)
}
function run() {
try {
async_error();
} catch (err) {
console.log(err);
}
}
run();
|
在回调函数内捕获错误，我们不得不在异步函数内写错误处理语句。
1
2
3
4
5
6
7
8
9
10
11
12
| function async_error() {
setTimeout(function(){
try{
throw new Error("Error");
}catch(e){
console.log(e);
}
},10)
}
async_error();
|
如果函数嵌套过多，就会变成这样
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| foo('a', function (a) {
if (a.error) {
throw new Error(a.error);
}
foo('b', function (b) {
if (b.error) {
throw new Error(b.error);
}
foo('c', function (c) {
if (c.error) {
throw new Error(c.error);
}
console.log(a, b, c);
});
});
});
|
但是，在es6里，这个就变的很简单。
1
2
3
4
5
6
7
8
9
10
11
| function* g(){
try {
var a = yield foo('a');
var b = yield foo('b');
var c = yield foo('c');
} catch (e) {
console.log(e);
}
console.log(a, b, c);
}
|
如果我们使用async来控制流程
1
2
3
4
5
6
7
8
9
10
11
| var async = require('async');
async.series([
function(cb){
cb(null);
},
function(cb){
cb(new Error("Error"));
}
],function(err){
console.log(err);
});
|
async串行执行函数过程中，一旦错误，就会停止执行剩下的函数，直接执行结果回调函数。这样就统一处理错误，变得很清晰。
那么使用promise呢
1
2
3
4
5
6
7
8
9
10
11
12
13
| var promise = new Promise(function(resolve, reject) {
if (){
resolve(value);
} else {
reject(error);
}
});
promise.then(function(value) {
}, function(value) {
});
|
promise中每个函数执行都有一个错误处理函数。
流程控制库帮助我们简化来错误处理机制。
另外，我们也可以用 events 来帮助触发错误处理函数。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| var events = require('events');
var util = require('util');
function A(){
events.EventEmitter.call(this);
}
util.inherits(A, events.EventEmitter);
var a = new A();
a.on('error',function(e){
console.log(e)
});
a.emit('error',new Error('a'));
|