Manejo de errores en Node.js

Cómo manejar errores durante la ejecución de una aplicación Node.js

Los errores en Node.js se manejan mediante excepciones.

Creando excepciones

Se crea una excepción utilizando elthrowpalabra clave:

throw value

Tan pronto como JavaScript ejecuta esta línea, el flujo normal del programa se detiene y el control se retiene al más cercanomanejador de excepciones.

Por lo general, en el código del lado del clientevaluepuede ser cualquier valor de JavaScript, incluida una cadena, un número o un objeto.

En Node.js, no lanzamos cadenas, solo lanzamos objetos Error.

Objetos de error

Un objeto de error es un objeto que es una instancia del objeto Error o extiende la clase Error, proporcionada en elMódulo central de error:

throw new Error('Ran out of coffee')

o

class NotEnoughCoffeeError extends Error {
  //...
}
throw new NotEnoughCoffeeError

Manejo de excepciones

Un controlador de excepciones es untry/catchdeclaración.

Cualquier excepción planteada en las líneas de código incluidas en eltrybloque se maneja en el correspondientecatchcuadra:

try {
  //lines of code
} catch (e) {

}

een este ejemplo es el valor de excepción.

Puede agregar varios controladores, que pueden detectar diferentes tipos de errores.

Detectando excepciones no detectadas

Si se lanza una excepción no detectada durante la ejecución de su programa, su programa se bloqueará.

Para resolver esto, escuche eluncaughtExceptionevento en elprocessobjeto:

process.on('uncaughtException', (err) => {
    console.error('There was an uncaught error', err)
    process.exit(1) //mandatory (as per the Node docs)
})

No es necesario importar elprocessmódulo principal para esto, ya que se inyecta automáticamente.

Excepciones con promesas

Al usar promesas, puede encadenar diferentes operaciones y manejar los errores al final:

doSomething1()
  .then(doSomething2())
  .then(doSomething3())
  .catch(err => console.error(err))

¿Cómo sabe dónde ocurrió el error? Realmente no lo sabe, pero puede manejar errores en cada una de las funciones que llama (doSomethingX), y dentro del controlador de errores arrojará un nuevo error, que llamará al exteriorcatchmanipulador:

const doSomething1 = () => {
  //...
  try {
    //...
  } catch (err) {
    //... handle it locally
    throw new Error(err.message)
  }
  //...
}

Para poder manejar errores localmente sin manejarlos en la función que llamamos, podemos romper la cadena, puede crear una función en cada uno.then()y procesar la excepción:

doSomething1
  .then((() => {
    return doSomething2().catch(err => {
      //handle error
      throw err //break the chain!
    })
  })
  .then((() => {
    return doSomething2().catch(err => {
      //handle error
      throw err //break the chain!
    })
  })
  .catch(err => console.error(err))

Manejo de errores con async / await

Usando async / await, aún necesita detectar errores, y lo hace de esta manera:

async function someFunction() {
  try {
    await someOtherFunction()
  }
  catch (err) {
    console.error(err.message)
  }
}

Descarga mi gratisManual de Node.js


Más tutoriales de nodos: