¿Cómo resolver demasiados intentos de captura en Typescript?

En este artículo, intentaremos ver cómo escribimos demasiados bloques try/catch para detectar múltiples errores en TypeScript y, además, intentaremos comprender con qué técnica podemos reducir la sobrecarga de escribir demasiados bloques try /catch bloques, con la ayuda de ciertos ejemplos de codificación. La declaración try-catch contiene el bloque try con el bloque catch o el bloque finalmente o contiene ambos bloques. El bloque de prueba se ejecutará primero, el bloque de captura solo se ejecutará si se lanza una excepción. El bloque final siempre se ejecuta antes de salir del flujo de control de todo el código.

Necesidad de bloques de prueba/captura:

• En palabras simples, necesitamos bloques try/catch para capturar todos los errores que recibimos de diferentes funciones.
• Detectar esos errores mejora el rendimiento de nuestro código y, por lo tanto, también la legibilidad. 
• Se requieren múltiples bloques try/catch para detectar múltiples errores de múltiples funciones una tras otra.

Sintaxis:

try {
    // Here we will all those variables or methods...
    // which tends to cause error or exception laterwards...
}

catch(error_variable){
    // do something with the error_variable...
    // either handle it or print it as per need...
}
...
// Many more such blocks could be added as per need....

Veamos las siguientes ilustraciones que nos ayudarán a comprender cuántos bloques de prueba/captura de más se pueden crear y también veremos la mejor versión en lugar de demasiados bloques de prueba/captura.

Ejemplo-1: En este ejemplo, crearemos múltiples bloques try/catch para detectar múltiples errores de diferentes funciones que en realidad arrojan diferentes errores individualmente y, al final, intentaremos imprimir esos mensajes de error uno tras otro.

let first_function = (content: string): any => {
    throw new Error(content);
}
  
let second_function = (content: string): any => {
    throw new Error(content);
}
  
let third_function = (content: string): any => {
    throw new Error(content);
}
  
let main_function = (): any => {
    try {
        let result = first_function(
            "Error 404 !!....");
        console.log(result);
    }
    catch (error) {
        console.log(error.message)
    }
  
    try {
        let result = second_function(
            "Something went wrong!!....");
        console.log(result);
    }
    catch (error) {
        console.log(error.message)
    }
  
    try {
        let result = third_function(
            "Please try again later!!....");
        console.log(result);
    }
    catch (error) {
        console.log(error.message)
    }
}
main_function();

Producción:

Error 404 !!....
Something went wrong!!....
Please try again later!!....

Del ejemplo anterior, la adición de múltiples bloques try/catch en realidad hace que el código parezca más grande y su legibilidad también se reduce hasta cierto punto por lo que ningún usuario desea optar.

Ahora, en otro ejemplo, intentaremos entender la otra forma posible para detectar los errores generados por varias funciones sin el uso de múltiples bloques de prueba/captura, como analizar la otra salida para reducir la sobrecarga de múltiples intentos/capturas. bloques Aquí, usaremos el concepto de la función de devolución de llamada (una función que se pasa dentro de otra función como argumento, que se ejecuta después de completar la primera función, que es la función principal en sí misma). Usaremos una función de devolución de llamada que es responsable de detectar el error arrojado por cada método dentro del bloque de prueba que se declarará dentro de una función contenedora (también denominada función de ayuda) a través de la cual detectaremos todos los errores de todas las funciones uno tras otro. otro.

Ejemplo 2: En este ejemplo, usaremos la función de devolución de llamada con bloques try/catch, para manejar la excepción lanzada.

let first_function = (content: string): any => {
    throw new Error(content);
};
  
let second_function = (content: string): any => {
    throw new Error(content);
};
  
let third_function = (content: string): any => {
    throw new Error(content);
};
  
let catchAllErrors = (callback: any, content: string): any => {
    try {
        callback(content);
    } catch (error) {
        return error;
    }
};
  
let main_function = () => {
  
    let error_1 = catchAllErrors(first_function,
        "Error 404!!...");
    let error_2 = catchAllErrors(second_function,
        "Something went wrong!!...");
    let error_3 = catchAllErrors(third_function,
        "Please try again later!!....");
  
    console.log("First Error: " + error_1);
    console.log("Second Error: " + error_2);
    console.log("Third Error: " + error_3);
};
main_function();

Producción:

First Error: Error: Error 404!!...
Second Error: Error: Something went wrong!!...
Third Error: Error: Please try again later!!....