¿Cómo manejar los errores cuando se trata de código asíncrono?

El código asíncrono en Node.js es un código que no bloquea la ejecución del código posterior. En el código síncrono, el código espera la ejecución de código adicional hasta que la operación actual no se completa y se ejecuta de arriba hacia abajo, mientras que en el código asíncrono, el código asíncrono se ejecuta en un subproceso separado para que la ejecución de código adicional no se bloquee y, por lo tanto, ambos se ejecutan simultáneamente. Para obtener una comprensión más profunda de la programación asíncrona, consulte ¿Cómo funciona el código asíncrono en JavaScript?

Ahora analicemos cómo manejar los errores en el código asíncrono.

Uso de devoluciones de llamada: una función de devolución de llamada es una función que se pasa como último parámetro en una función asíncrona y se llama a una devolución de llamada cuando se ejecuta la función asíncrona. El primer parámetro en cualquier función de devolución de llamada es el objeto de error, por lo que a menudo se les conoce como devoluciones de llamada de error primero. Si no hay error, el objeto de error es nulo; de lo contrario, contendrá información sobre el error. 

Ejemplo: En el siguiente ejemplo, usamos el método setTimeout para hacer que nuestra función mod sea asíncrona. Si b es cero, pasamos un error que dice «No se permite el módulo cero», de lo contrario, registramos el resultado. De esta manera, nuestra devolución de llamada maneja los errores cada vez que se llama a la función mod.

<script>
    const mod = (a, b, callback) => {
        setTimeout(() => {
            if (b == 0) {
                // Error 
                callback("Modulo zero is not allowed");
            } else {
                // Success
                callback(null, a % b);
            }
        }, 0);
    };
  
    // 5 mod 2 will give result 1
    mod(5, 2, (err, res) => {
        if (err) {
            console.log(err);
        }
        else {
            console.log('The result is ' + res);
        }
    });
  
    // 5 mod 0 will give error
    mod(5, 0, (err, res) => {
        if (err) {
            console.log(err);
        }
        else {
            console.log(`The result is ${res}`);
        }
    });
</script>

Producción:

The result is 1
Modulo zero is not allowed

Pero cuando usamos el método de devolución de llamada, a veces podemos quedar atrapados en el infierno de devolución de llamada . Para evitar eso, usamos Promesas discutidas a continuación.

Uso de promesas: las promesas nos permiten manejar operaciones asincrónicas en Nodejs sin quedar atrapados en el infierno de devolución de llamada. Una promesa se resuelve o se rechaza. Hay dos métodos then() y catch() después de que se resuelva o rechace una promesa. Si se resuelve, entonces se ejecuta el código en el método then(); de lo contrario, obtenemos el error a través del bloque catch.

Ejemplo: modifiquemos el ejemplo anterior y manejemos los errores usando promesas.

<script>
    const mod = (a, b) => {
        return new Promise((resolve, reject) => {
            if (b == 0) {
                // Rejected (error)
                reject("Modulo zero is not allowed");
            } else {
                //Resolved (Success)
                resolve(a % b);
            }
        })
    };
  
    // 5 mod 2 will give result 1
    mod(5, 2).then((res) => {
        console.log(`The result is ${res}`);
    }).catch((err) => {
        console.log(err);
    });
  
    // 5 mod 0 will give error
    mod(5, 0).then((res) => {
        console.log(`The result is ${res}`);
    }).catch((err) => {
        console.log(err);
    });
</script>

Producción:

The result is 1
Modulo zero is not allowed

El código es más limpio ahora que antes cuando usábamos devoluciones de llamada. Aunque Promises nos permitió evitar los infiernos de devolución de llamada, tienen su propia complejidad de sintaxis, por lo que tenemos las funciones Async que se analizan a continuación.

Uso de Async/Await: Async/Await facilita el trabajo con las promesas de JavaScript. Nos permite manejar errores usando el bloque try-catch . Para usar async-await, solo necesitamos crear una función asíncrona en la que implementaremos nuestro bloque try-catch. En el bloque de prueba, esperaremos a que se complete nuestra promesa. Si se resuelve, obtendremos el resultado; de lo contrario, se generará un error a través del bloque catch. Await solo se puede usar dentro de una función asíncrona, devolución de llamada asíncrona o función de flecha asíncrona.

Ejemplo: 

<script>
    const mod = (a, b) => {
        return new Promise((resolve, reject) => {
            if (b == 0) {
                // Rejected (error)
                reject("Modulo zero is not allowed");
            } else {
                //Resolved (Success)
                resolve(a % b);
            }
        });
    };
  
    // 5 mod 2 will give result 1
    async function _5mod2() {
        try {
            const res = await mod(5, 2);
            console.log(`The result of division is ${res}`);
        } catch (err) {
            console.log(err);
        }
    };
    _5mod2();
  
    // 5 mod 0 will give error
    async function _5mod0() {
        try {
            const res = await mod(5, 0);
            console.log(`The result of division is ${res}`);
        } catch (err) {
            console.log(err);
        }
    };
    _5mod0();
</script>

Producción:

The result of division is 1
Modulo zero is not allowed