10.1 Bloque try...catch
El manejo de excepciones es un aspecto importante de la programación que ayuda a mejorar la estabilidad y confiabilidad del código. En JavaScript, se utilizan las palabras clave try, catch, finally y throw para el manejo de excepciones. En la conferencia, revisaremos estas palabras clave, su sintaxis y ejemplos de uso.
1. Bloque try...catch
La construcción try...catch se utiliza para manejar errores que ocurren en el bloque de código try. Si en el bloque try ocurre un error, el control se transfiere al bloque catch, donde el error puede ser manejado.
Sintaxis:
try {
// Código que puede lanzar una excepción
} catch (error) {
// Código para manejar la excepción
}
En este ejemplo, aunque la división por cero no lanza un error en JavaScript, si fuera otro error (por ejemplo, acceso a una variable no definida), el bloque catch lo manejaría:
try {
let result = 10 / 0;
console.log(result);
} catch (error) {
console.error('An error occurred:', error);
}
10.2. Bloque finally
El bloque finally se utiliza para ejecutar código que debe ser ejecutado independientemente de si ocurrió una excepción en el bloque try o no. El bloque finally sigue al bloque catch.
Sintaxis:
try {
// Código que puede lanzar una excepción
} catch (error) {
// Código para manejar la excepción
} finally {
// Código que se ejecutará de todas formas
}
En este ejemplo, el mensaje This will always execute. se mostrará independientemente de si ocurrió un error o no:
try {
let result = 10 / 0;
console.log(result);
} catch (error) {
console.error('An error occurred:', error);
} finally {
console.log('This will always execute.');
}
10. 3. Operador throw
El operador throw se utiliza para lanzar explícitamente excepciones. Con su ayuda, se pueden lanzar errores personalizados.
Sintaxis:
throw expression;
Dónde:
expression: cualquier expresión u objeto que será lanzado como excepción
Ejemplo de uso
En este ejemplo, se lanza un error si se intenta dividir por cero, y el bloque catch maneja este error:
function divide(a, b) {
if (b === 0) {
throw new Error('Division by zero is not allowed.');
}
return a / b;
}
try {
let result = divide(10, 0);
console.log(result);
} catch (error) {
console.error('An error occurred:', error.message);
}
10.4 Ejemplos avanzados y uso
Ejemplo 1: Múltiples excepciones
A veces, en el bloque try pueden ocurrir diferentes tipos de errores. Puedes manejarlos de diferentes maneras, utilizando propiedades del objeto error.
En este ejemplo, manejamos un error de sintaxis JSON por separado de otros posibles errores:
try {
JSON.parse('{ malformed JSON string }');
} catch (error) {
if (error instanceof SyntaxError) {
console.error('JSON Syntax Error:', error.message);
} else {
console.error('Unexpected Error:', error);
}
} finally {
console.log('Parsing attempt finished.');
}
Ejemplo 2: Bloques anidados try...catch
Se pueden usar bloques anidados try...catch para un manejo de errores más fino.
En este ejemplo, un error que ocurre en el primer bloque try es manejado por el bloque catch interno, que luego vuelve a lanzar el error para ser manejado por el bloque catch externo:
try {
try {
let result = divide(10, 0);
console.log(result);
} catch (innerError) {
console.error('Inner catch:', innerError.message);
throw innerError;
}
} catch (outerError) {
console.error('Outer catch:', outerError.message);
} finally {
console.log('Nested try...catch finished.');
}
function divide(a, b) {
if (b === 0) {
throw new Error('Division by zero is not allowed.');
}
return a / b;
}
Ejemplo 3: Uso de finally para liberar recursos
El bloque finally es útil para liberar recursos, como cerrar archivos o finalizar conexiones de red.
En este ejemplo, el archivo siempre se cerrará, independientemente de si ocurrió un error al leerlo o no:
function readFile(filePath) {
let file;
try {
file = openFile(filePath); // Función para abrir el archivo
// Trabajo con el archivo
} catch (error) {
console.error('Error reading file:', error.message);
} finally {
if (file) {
closeFile(file); // Función para cerrar el archivo
}
console.log('File processing finished.');
}
}
function openFile(path) {
// Lógica para abrir el archivo
}
function closeFile(file) {
// Lógica para cerrar el archivo
}
readFile('path/to/file.txt');
El manejo de excepciones en JavaScript utilizando try, catch, finally y throw permite crear aplicaciones más confiables y resistentes. Comprender y usar correctamente estas construcciones ayuda a manejar errores eficazmente, liberar recursos y mejorar la experiencia del usuario.
GO TO FULL VERSION