在nodejs开发中，异常处理十分麻烦。一下代码捕捉不到错误

function async_error() {
    setTimeout(function(){
            throw new Error("Error");
    },10)
}

function run() {
    try {
        async_error();
    } catch (err) {
        console.log(err);
    }
}

run();

在回调函数内捕获错误，我们不得不在异步函数内写错误处理语句。

function async_error() {
    setTimeout(function(){
    		try{
    			throw new Error("Error");
    		}catch(e){
    			console.log(e);
    		}
            
    },10)
}

async_error();

如果函数嵌套过多，就会变成这样

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里，这个就变的很简单。

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来控制流程

var async = require('async');
async.series([
	function(cb){
			cb(null);
	},
	function(cb){
			cb(new Error("Error"));
	}
	],function(err){
	console.log(err);	
});

async串行执行函数过程中，一旦错误，就会停止执行剩下的函数，直接执行结果回调函数。这样就统一处理错误，变得很清晰。

那么使用promise呢

var promise = new Promise(function(resolve, reject) {
  if (/* 异步操作成功 */){
    resolve(value);
  } else {
    reject(error);
  }
});

promise.then(function(value) {
  // success
}, function(value) {
  // failure
});

promise中每个函数执行都有一个错误处理函数。

流程控制库帮助我们简化来错误处理机制。

另外，我们也可以用 events 来帮助触发错误处理函数。

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'));