Explicar algunos enfoques de manejo de errores en Node.js

Node.js es un entorno de tiempo de ejecución de JavaScript de código abierto. A menudo se usa en el lado del servidor para crear API para aplicaciones web y móviles. Una gran cantidad de empresas como Netflix, Paypal, Uber, etc. utilizan Node.js.

requisitos previos:

• promesas
• Espera asíncrona

Un error es cualquier problema dado por el programa debido a una serie de factores como la lógica, la sintaxis, el tiempo de espera, etc. El manejo de errores es una parte importante de Node.js y debe implementarse con cuidado. En este tutorial, echemos un vistazo a algunos enfoques para manejar los errores, pero primero configuremos nuestro entorno básico.

Cree un archivo llamado error.js. Este archivo servirá como base para explorar los diversos métodos.

Método 1: usar un bloque de prueba y captura.

El bloque catch maneja cualquier excepción generada por el código en el bloque try. 

Sintaxis:

try{
    // Code
}catch(error){
    // Error Handling
}

Ejemplo:

try{
    const areYouAwesome = false;
    if(!areYouAwesome){
        throw new Error("We know you are awesome, 
                       we are having troubing with our code.")
    }
}catch(error){
    console.log(error.message);
}

Producción:

We know you are awesome, we are having troubing with our code.

Método 2: usar try-catch mientras se realizan operaciones asincrónicas

Las operaciones asincrónicas a veces requieren que el programa se detenga mientras se recuperan los datos. Podemos emparejar funciones asíncronas de espera con bloques de prueba y captura para manejar errores. 

Sintaxis:

const myFunction = async () => {
    try{
        await operationWhichTakesTime()
    }catch(error){
        // Error handling
    }
}

Ejemplo:

const delay = (wait) => {
    return new Promise(resolve => setTimeout(resolve, wait));
}
  
const awesomeFunction = async () => {
    try{
        await delay(2000)
        throw new Error("Error thrown after delay");
    }catch(error){
        console.log(error.message);
    }
}
  
awesomeFunction();

Producción:

Error thrown after delay

Método 3: Usar promesas

Las promesas se utilizan para manejar operaciones asincrónicas en JavaScript. Son tres estados para una promesa, a saber, el estado pendiente, el estado resuelto y el estado rechazado. En el estado pendiente, la promesa está esperando alguna otra función o que se recuperen algunos datos. En el estado resuelto, la función ha funcionado según lo previsto y la promesa está resuelta. En el estado rechazado, se ha producido algún error en la función y se rechaza la promesa.

Sintaxis:

promise().then((data) => {
    // Code
}).catch((error) => {
    // Error handler
})

Ejemplo:

const awesomeFunction = (isAwesome) => {
    return new Promise((resolve, reject) => {
        if(isAwesome){
            resolve("You are awesome");
        }else{
            reject("We know you are awesome, 
                   we are having troubing with our code.")
        }
    })
} 
  
awesomeFunction(false).then((message) => {
    console.log(message);
}).catch((error) => {
    console.log(error)
});

Producción:

We know you are awesome, we are having troubing with our code.

Método 4: usar un detector de eventos 

El objeto global de proceso en Node.js se puede usar para escuchar cualquier excepción no detectada que pueda haberse infiltrado en el programa.

Sintaxis:

process.on('uncaughtException', error => {
    // Error Handling
    process.exit(1)
})

Ejemplo:

process.on('uncaughtException', error => {
    console.log(error.message);
    process.exit(1) 
})  
  
const awesomeFunction = (isAwesome) => {
    if(!isAwesome){
        throw new Error("We know you are awesome, 
                     we are having troubing with our code.")
    }
} 
  
awesomeFunction();

Producción:

We know you are awesome, we are having troubing with our code.