Node.js Mejores Prácticas De Manejo De Excepciones

Actualización: Joyent ahora tiene su propia guía mencionados en esta respuesta. La siguiente información es más que un resumen:

De forma segura "tirar" de los errores

Idealmente, nos gustaría evitar uncaught errores en la medida de lo posible, como tales, en lugar de literalmente, tirar el error, por el contrario, podemos con seguridad "lanzar" el error usando uno de los siguientes métodos, dependiendo de nuestro código de arquitectura:

• Para el código sincrónico, si ocurre un error, el error:

  // Define divider as a syncrhonous function
  var divideSync = function(x,y) {
      // if error condition?
      if ( y === 0 ) {
          // "throw" the error safely by returning it
          return new Error("Can't divide by zero");
      }
      else {
          // no error occured, continue on
          return x/y;
      }
  };
  
  // Divide 4/2
  var result;
  result = divideSync(4,2);
  // did an error occur?
  if ( result instanceof Error ) {
      // handle the error safely
      console.log('4/2=err', result);
  }
  else {
      // no error occured, continue on
      console.log('4/2='+result);
  }
  
  // Divide 4/0
  result = divideSync(4,0);
  // did an error occur?
  if ( result instanceof Error ) {
      // handle the error safely
      console.log('4/0=err', result);
  }
  else {
      // no error occured, continue on
      console.log('4/0='+result);
  }
  

• Para la devolución de llamada (es decir. asincrónico) del código, el primer argumento de la devolución de llamada, err, si ocurre un error err es el error, si un error de que no suceda, a continuación, err es null. Cualquier otro argumento siga las err argumento:

  var divide = function(x,y,next) {
      // if error condition?
      if ( y === 0 ) {
          // "throw" the error safely by calling the completion callback
          // with the first argument being the error
          next(new Error("Can't divide by zero"));
      }
      else {
          // no error occured, continue on
          next(null, x/y);
      }
  };
  
  divide(4,2,function(err,result){
      // did an error occur?
      if ( err ) {
          // handle the error safely
          console.log('4/2=err', err);
      }
      else {
          // no error occured, continue on
          console.log('4/2='+result);
      }
  });
  
  divide(4,0,function(err,result){
      // did an error occur?
      if ( err ) {
          // handle the error safely
          console.log('4/0=err', err);
      }
      else {
          // no error occured, continue on
          console.log('4/0='+result);
      }
  });
  

• Para agitada código, donde el error puede ocurrir en cualquier lugar, en lugar de tirar el error, el fuego la error evento lugar:

  // Definite our Divider Event Emitter
  var events = require('events');
  var Divider = function(){
      events.EventEmitter.call(this);
  };  require('util').inherits(Divider, events.EventEmitter);
  
  // Add the divide function
  Divider.prototype.divide = function(x,y){
      // if error condition?
      if ( y === 0 ) {
          // "throw" the error safely by emitting it
          var err = new Error("Can't divide by zero");
          this.emit('error', err);
      }
      else {
          // no error occured, continue on
          this.emit('divided', x, y, x/y);
      }
  
      // Chain
      return this;
  };
  
  // Create our divider and listen for errors
  var divider = new Divider();
  divider.on('error', function(err){
      // handle the error safely
      console.log(err);
  });
  divider.on('divided', function(x,y,result){
      console.log(x+'/'+y+'='+result);
  });
  
  // Divide
  divider.divide(4,2).divide(4,0);
  

De forma segura "de la captura de los" errores

A veces, sin embargo, puede todavía ser código que produce un error en alguna parte que puede conducir a una excepción no capturada y potenciales de accidentes de nuestra aplicación si no captamos de manera segura. Dependiendo de nuestro código de la arquitectura podemos utilizar uno de los siguientes métodos de captura:

• Cuando sabemos dónde se produce el error, se puede envolver esa sección en un node.js dominio

  var d = require('domain').create();
  d.on('error', function(err){
      // handle the error safely
      console.log(err);
  });
  
  // catch the uncaught errors in this asynchronous or synchronous code block
  d.run(function(){
      // the asynchronous or synchronous code that we want to catch thrown errors on
      var err = new Error('example');
      throw err;
  });
  

• Si sabemos dónde se produce el error es de código sincrónico, y que por cualquier razón no se puede utilizar dominios (quizás versión antigua de nodo), podemos utilizar el try catch declaración:

  // catch the uncaught errors in this synchronous code block
  // try catch statements only work on synchronous code
  try {
      // the synchronous code that we want to catch thrown errors on
      var err = new Error('example');
      throw err;
  } catch (err) {
      // handle the error safely
      console.log(err);
  }
  

• Sin embargo, todavía puede haber un caso en el que dicho error sucede en un lugar que no estaba envuelto en un dominio o un try catch declaración, en cuyo caso para hacer que nuestra aplicación no falla, podemos usar la uncaughtException oyente (sin embargo, si lo puede poner la aplicación en un estado desconocido):

  // catch the uncaught errors that weren't wrapped in a domain or try catch statement
  // do not use this in modules, but only in applications, as otherwise we could have multiple of these bound
  process.on('uncaughtException', function(err) {
      // handle the error safely
      console.log(err);
  });
  
  // the asynchronous or synchronous code that emits the otherwise uncaught error
  var err = new Error('example');
  throw err;