Lanzar un error en Node.js

La publicación de hoy nos enseñará cómo arrojar un error en Node.js.

Lanzar un error en Node.js

Los errores son declaraciones que no permiten que el sistema funcione correctamente.

Los errores en Node.Js se tratan mediante excepciones, que se crean con la ayuda de la palabra clave throw. Esto podría ayudar a los usuarios a crear excepciones personalizadas.

Tan pronto como se ejecuta esta línea de código JavaScript, el flujo normal del programa se detiene y el control se mantiene en el controlador de excepciones más cercano. El programa termina si no existe ningún bloque catch entre las funciones de llamada.

Sintaxis:

throw expression;

El valor normalmente puede ser cualquier valor de JavaScript en el código del lado del cliente, incluido un número, un objeto o una cadena. Pero en Node.js, no arrojamos cadenas; solo lanzamos objetos Error.

El objeto de error

Un objeto de error es un objeto que es una instancia del objeto Error o amplía la clase Error proporcionada en el módulo principal Error. Los objetos de error se generan cuando se producen errores de tiempo de ejecución.

También podemos usar el objeto de error como objeto base para excepciones personalizadas.

throw new Error('You reached the end!');
class MyCustomError extends Error {
  // ...
}
throw new MyCustomError();

Manejar excepciones

El manejador de excepciones es la sentencia try...catch. Cualquier excepción lanzada en las líneas de código contenidas en el bloque try se maneja en el bloque catch apropiado.

Si se lanza una excepción no detectada mientras su programa se está ejecutando, su programa fallará.

try {
  /* Your Regular Code */
} catch (e) {
  /* Catch your exception here */
}

e es el valor de excepción en este ejemplo. Puede agregar varios controladores que pueden detectar diferentes tipos de errores.

Según el tipo de excepción, puede modificar su programa. Para solucionar el problema de falla del programa, espere el evento uncaughtException en el objeto del proceso.

process.on('uncaughtException', err => {
  console.error('An uncaught error is caught here', err);
  process.exit(1);
});

No necesita importar el módulo principal de proceso para esto, ya que se incluirá automáticamente.

Manejar excepciones con promesas

Las promesas le permitirán encadenar operaciones únicas de forma colectiva y gestionar los errores al final. Las cadenas de promesas son increíbles para lidiar con el error.

Cuando se rechaza una promesa, el control salta al controlador de rechazo más cercano. Eso es muy conveniente en la práctica.

Como puedes ver, el .catch no tiene por qué ser instantáneo. Puede parecer después de uno o tal vez numerosos .entonces.

fooFunction()
    .then(barFunction)
    .then(fooBarFunction)
    .catch(err => console.error(err));

Manejar excepciones con async/await

Usando async/await, necesitas detectar errores usando try...catch.

async function fooFunction() {
  try {
    await fooBarFunction();
  } catch (err) {
    console.error(err.message);
  }
}

Entendámoslo con el ejemplo simple a continuación:

fooBarFunction =
    async () => {
  throw new Error('Hello DelftStack Users!')
}

async function fooFunction() {
  try {
    console.log('Before Error') await fooBarFunction();
  } catch (err) {
    console.error(err.message);
  }
} fooFunction()

En el ejemplo anterior, llamamos a fooFunction(), que primero imprime el mensaje y luego llama a fooBarFunction() internamente. En fooBarFunction(), simplemente lanzamos un error que es detectado por fooFunction().

Intente ejecutar el fragmento de código anterior en Replit, que es compatible con Node.js. Va a mostrar el siguiente resultado:

Producción :

Before Error
Hello DelftStack Users!

Ejecutar demostración