JavaScript
Manejo de errores

Sintaxis

• prueba {...} captura (error) {...}
• intente {…} finalmente {…}
• intente {...} atrapar (error) {...} finalmente {...}
• lanzar nuevo error ([mensaje]);
• lanzar Error ([mensaje]);

Observaciones

Interacción con Promesas

Promise.resolve(5)
    .then(result => {
        throw new Error("I don't like five");
    })
    .then(result => {
        console.info("Promise resolved: " + result);
    })
    .catch(error => {
        console.error("Promise rejected: " + error);
    });

Promise rejected: Error: I don't like five

async function main() {
  try {
    await Promise.reject(new Error("Invalid something"));
  } catch (error) {
    console.log("Caught error: " + error);
  }
}
main();

Caught error: Invalid something

Objetos de error

Los errores de tiempo de ejecución en JavaScript son instancias del objeto Error . El objeto Error también se puede usar como está, o como la base para excepciones definidas por el usuario. Es posible lanzar cualquier tipo de valor, por ejemplo, cadenas, pero se recomienda encarecidamente que utilice Error o uno de sus derivados para asegurarse de que la información de depuración, como las huellas de la pila, se conserve correctamente.

El primer parámetro del constructor de Error es el mensaje de error legible. Debe intentar especificar siempre un mensaje de error útil de lo que salió mal, incluso si se puede encontrar información adicional en otro lugar.

try {
   throw new Error('Useful message');
} catch (error) {
   console.log('Something went wrong! ' + error.message);
}

Orden de operaciones mas pensamientos avanzados

Sin un bloque try catch, las funciones no definidas generarán errores y detendrán la ejecución:

undefinedFunction("This will not get executed");
console.log("I will never run because of the uncaught error!");

Lanzará un error y no ejecutará la segunda línea:

// Uncaught ReferenceError: undefinedFunction is not defined

Necesita un bloque try catch, similar a otros idiomas, para asegurarse de detectar ese error para que el código pueda continuar ejecutándose:

try {
    undefinedFunction("This will not get executed");
} catch(error) {
    console.log("An error occured!", error);
} finally {
    console.log("The code-block has finished");
}
console.log("I will run because we caught the error!");

Ahora, hemos detectado el error y podemos estar seguros de que nuestro código se ejecutará

// An error occured! ReferenceError: undefinedFunction is not defined(…)
// The code-block has finished
// I will run because we caught the error!

¿Qué pasa si se produce un error en nuestro bloque catch?

try {
    undefinedFunction("This will not get executed");
} catch(error) {
    otherUndefinedFunction("Uh oh... ");
    console.log("An error occured!", error);
} finally {
    console.log("The code-block has finished");
}
console.log("I won't run because of the uncaught error in the catch block!");

No procesaremos el resto de nuestro bloque catch, y la ejecución se detendrá a excepción del bloque finally.

// The code-block has finished
// Uncaught ReferenceError: otherUndefinedFunction is not defined(…)

Siempre puedes anidar tus bloques de captura de prueba ... pero no deberías porque eso se volverá extremadamente complicado ...

try {
    undefinedFunction("This will not get executed");
} catch(error) {
    try {
        otherUndefinedFunction("Uh oh... ");
    } catch(error2) {
        console.log("Too much nesting is bad for my heart and soul...");
    }
    console.log("An error occured!", error);
} finally {
    console.log("The code-block has finished");
}
console.log("I will run because we caught the error!");

Capturará todos los errores del ejemplo anterior y registrará lo siguiente:

//Too much nesting is bad for my heart and soul...
//An error occured! ReferenceError: undefinedFunction is not defined(…)
//The code-block has finished
//I will run because we caught the error!

Entonces, ¿cómo podemos detectar todos los errores? Para variables y funciones no definidas: no se puede.

Además, no debes envolver cada variable y función en un bloque try / catch, porque estos son ejemplos simples que solo se producirán una vez hasta que los arregles. Sin embargo, para objetos, funciones y otras variables que sabe que existen, pero no sabe si existirán sus propiedades, subprocesos o efectos secundarios, o si espera algunos estados de error en algunas circunstancias, debe abstraer su manejo de errores. de alguna manera Aquí hay un ejemplo y una implementación muy básicos.

Sin una forma protegida de llamar a métodos no confiables o de excepción:

function foo(a, b, c) {
    console.log(a, b, c);
    throw new Error("custom error!");
}
try {
    foo(1, 2, 3);
} catch(e) { 
    try {
        foo(4, 5, 6); 
    } catch(e2) {
        console.log("We had to nest because there's currently no other way...");
    }
    console.log(e);
}
// 1 2 3
// 4 5 6
// We had to nest because there's currently no other way...
// Error: custom error!(…)

Y con protección:

function foo(a, b, c) {
    console.log(a, b, c);
    throw new Error("custom error!");
}
function protectedFunction(fn, ...args) {
    try {
        fn.apply(this, args);
    } catch (e) {
        console.log("caught error: " + e.name + " -> " + e.message);
    }
}

protectedFunction(foo, 1, 2, 3);
protectedFunction(foo, 4, 5, 6);

// 1 2 3
// caught error: Error -> custom error!
// 4 5 6
// caught error: Error -> custom error!

Capturamos errores y aún procesamos todo el código esperado, aunque con una sintaxis algo diferente. De cualquier manera funcionará, pero a medida que desarrolle aplicaciones más avanzadas, querrá comenzar a pensar en formas de abstraer el manejo de sus errores.

Tipos de error

Hay seis constructores de error de núcleo específicos en JavaScript:

• EvalError : crea una instancia que representa un error que se produce con respecto a la función global eval() .

• InternalError : crea una instancia que representa un error que se produce cuando se produce un error interno en el motor de JavaScript. Por ejemplo, "demasiada recursión". (Soportado solo por Mozilla Firefox )

• RangeError : crea una instancia que representa un error que se produce cuando una variable o parámetro numérico está fuera de su rango válido.

• ReferenceError : crea una instancia que representa un error que se produce al eliminar la referencia de una referencia no válida.

• SyntaxError : crea una instancia que representa un error de sintaxis que se produce al analizar el código en eval() .

• TypeError : crea una instancia que representa un error que se produce cuando una variable o un parámetro no es de un tipo válido.

• URIError : crea una instancia que representa un error que se produce cuando encodeURI() o decodeURI() pasan parámetros no válidos.

Si está implementando un mecanismo de manejo de errores, puede verificar qué tipo de error está detectando desde el código.

try {
    throw new TypeError();
}
catch (e){
    if(e instanceof Error){
        console.log('instance of general Error constructor');
    }

    if(e instanceof TypeError) {
        console.log('type error');
    }
}

En tal caso, e será una instancia de TypeError . Todos los tipos de error amplían el Error constructor base, por lo que también es una instancia de Error .

Teniendo esto en cuenta, nos muestra que verificar que e sea ​​una instancia de Error es inútil en la mayoría de los casos.