¿Cómo manejar los errores de código asíncrono en Node.js?

La operación asíncrona en JavaScript es la operación que no bloquea otras operaciones. Significa que si realizamos una operación asíncrona en un punto determinado del código, el código posterior se ejecuta y no espera a que se complete esa operación asíncrona. Un ejemplo de una operación asíncrona en Node.js es cuando solicitamos algunos datos de un servidor web.

Si queremos manejar el error de código asíncrono en Node.js, podemos hacerlo de las siguientes dos maneras. 

• Manejar el error usando la devolución de llamada
• Manejar el rechazo de la promesa

Manejar el error usando la devolución de llamada: una función de devolución de llamada es realizar alguna operación después de que se completa la ejecución de la función. Podemos llamar a nuestra función de devolución de llamada después de que se complete una operación asincrónica. Si hay algún error, podemos llamar a la función de devolución de llamada con ese error; de lo contrario, podemos llamarla con el error como nulo y el resultado de la operación asincrónica como argumentos.

Configuración del proyecto:

Paso 1: Instale Node.js si aún no lo ha hecho.

Paso 2:  Cree una carpeta para su proyecto y cd (cambiar de directorio) en ella. Cree un nuevo archivo llamado app.js dentro de esa carpeta. 

Estructura del proyecto: después de seguir los pasos, la estructura de su proyecto se verá así.

En el ejemplo de código que se menciona a continuación, hemos simulado una operación asíncrona usando el método setTimeout(). Realizamos una operación de división que devuelve el resultado de la división después de 1 segundo y si el divisor es cero, pasamos una instancia de error al método de devolución de llamada. Si no hay ningún error, llamamos a la función de devolución de llamada con el error como nulo y el resultado de la división como argumentos. El error y el resultado se manejan dentro de nuestra función de devolución de llamada.

const divide = (a, b, callback) => {
  setTimeout(() => {
    if (b == 0) {
      callback(new Error('Division by zero error'));
    } else {
      callback(null, a / b);
    }
  }, 1000);
};
  
divide(10, 2, (err, res) => {
  if (err) {
    console.log(err.message);
  } else {
    console.log(`The result of division = ${res}`);
  }
});
  
divide(5, 0, (err, res) => {
  if (err) {
    console.log(err.message);
  } else {
    console.log(`The result of division = ${res}`);
  }
});

Paso para ejecutar la aplicación: puede ejecutar su archivo app.js usando el siguiente comando en la línea de comando.

node app.js

Producción: 

Manejar el rechazo de Promise: Promise en Node.js es una forma de manejar operaciones asincrónicas. Cuando devolvemos una promesa de una función asíncrona, luego se puede consumir usando el método then() o async/await para obtener el valor final. Cuando estamos usando el método then() para consumir la promesa y tenemos que manejar los rechazos de la promesa, entonces podemos hacer una llamada catch() a la llamada del método then(). Promise.catch() es un método que devuelve una promesa y su trabajo es lidiar con la promesa rechazada.

Sintaxis:

// func is an async function
func().then(res => {   
    // code logic
}).catch(err => {
    // promise rejection handling logic
})

Ahora, si queremos manejar los rechazos de Promise usando async/await, podemos hacerlo fácilmente usando un simple bloque try/catch como se muestra en la sintaxis que se proporciona a continuación.

const hello = async () => {
    try {
        // func is an async function
        const res = await func();
    } catch(err) {
        // error handling logic
    }
}

En el siguiente ejemplo, simulamos una función asíncrona con el método setTimeout() y realizamos la operación de división dentro de una función asíncrona que devuelve una Promesa. Si el divisor es cero, rechazamos la promesa con error, de lo contrario, la resolvemos con el resultado de la división. 

const divide = async (a, b) => {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      if (b == 0) {
        reject(new Error('Division by zero error'));
      } else {
        resolve(a / b);
      }
    }, 1000);
  });
};
  
// Consuming the promise using then() method
// and handling the rejected promise using
// catch() method
divide(5, 0)
  .then((res) => {
    console.log(`The result of division is ${res}`);
  })
  .catch((err) => {
    console.log(err.message);
  });
  
// This function is immedietly invoked after
// its execution. In this case we consume the
// promise returned by divide function() using
// async/await and handle the error using
// try/catch block
(async () => {
  try {
    const res = await divide(10, 5);
    console.log(`The result of division is ${res}`);
  } catch (err) {
    console.log(err);
  }
})();

Producción: