JavaScript: Controlando Errores con try…catch

En el mundo del desarrollo web, los errores son una realidad inevitable. JavaScript, como cualquier otro lenguaje de programación, es susceptible a errores de ejecución que pueden interrumpir el flujo normal de tu código. Para evitar que tu aplicación se bloquee y para garantizar un comportamiento estable y predecible, JavaScript ofrece una herramienta fundamental: la sentencia try...catch.

La sentencia try...catch es un mecanismo de control de errores que te permite capturar y manejar errores en tiempo de ejecución. Al encerrar código potencialmente problemático dentro del bloque try, puedes interceptar cualquier excepción que ocurra y ejecutar un bloque de código alternativo dentro del bloque catch, evitando que la aplicación se detenga abruptamente.

Sintaxis de try…catch

La sintaxis básica de la sentencia try...catch es bastante simple:

javascript
try {
// Código que puede generar errores
} catch (error) {
// Código a ejecutar si se produce un error
}


El bloque try contiene el código que quieres ejecutar. Si se produce un error durante la ejecución de este código, se lanzará una excepción. El bloque catch captura la excepción y ejecuta el código dentro de él. La variable error contiene información sobre el error que se produjo, incluyendo su tipo y mensaje.

Ejemplos de Uso de try…catch

Veamos algunos ejemplos de cómo utilizar try...catch para manejar diferentes tipos de errores comunes:

1. Referencia a una Variable no Definida:

javascript
try {
console.log(myVariable); // myVariable no está definida
} catch (error) {
console.error("Error: Variable no definida.", error);
}


2. Llamada a una Función No Existente:

javascript
try {
nonExistentFunction(); // La función no existe
} catch (error) {
console.error("Error: Función no encontrada.", error);
}


3. Validación de Entrada:

javascript
try {
let age = parseInt(prompt("Ingresa tu edad:"));
if (age < 0) {
throw new Error("Edad inválida: Debe ser un número positivo.");
}
console.log("Tu edad es:", age);
} catch (error) {
console.error("Error:", error.message);
}


La Sentencia finally

La sentencia finally es opcional y se utiliza para ejecutar un bloque de código independientemente de si se produjo un error o no. Esto es útil para liberar recursos o realizar tareas de limpieza, como cerrar conexiones de base de datos o archivos.

javascript
try {
// Código que puede generar errores
} catch (error) {
// Código a ejecutar si se produce un error
} finally {
// Código a ejecutar siempre, independientemente de si se produjo un error o no
}


La Sentencia throw

La sentencia throw permite lanzar manualmente una excepción. Esto es útil para generar errores personalizados o para interrumpir la ejecución del código de forma controlada.

«`javascript
function validateAge(age) {
if (age < 0) {
throw new Error(«Edad inválida: Debe ser un número positivo.»);
}
return true;
}

try {
validateAge(-10);
} catch (error) {
console.error(«Error:», error.message);
}
«`

Manejo de Errores Anidados

Puedes utilizar try...catch anidados para manejar errores que se produzcan en bloques try internos.

javascript
try {
try {
// Código que puede generar errores
} catch (innerError) {
// Código a ejecutar si se produce un error dentro del bloque interno
console.error("Error interno:", innerError);
}
} catch (outerError) {
// Código a ejecutar si se produce un error fuera del bloque interno
console.error("Error externo:", outerError);
}


Catch Condicional

Puedes utilizar la sentencia if...else dentro del bloque catch para manejar diferentes tipos de errores de forma específica.

javascript
try {
// Código que puede generar errores
} catch (error) {
if (error instanceof ReferenceError) {
console.error("Error: Referencia no definida.");
} else if (error instanceof TypeError) {
console.error("Error: Tipo de datos inválido.");
} else {
console.error("Error desconocido:", error);
}
}


Try…catch con setTimeout

Es importante tener en cuenta que try...catch no puede capturar errores lanzados en código asíncrono utilizando setTimeout. Esto se debe a que el código ejecutado por setTimeout se ejecuta en un entorno diferente al que está ejecutando el código dentro del bloque try.

javascript
setTimeout(() => {
try {
nonExistentFunction(); // La función no existe
} catch (error) {
console.error("Error:", error); // No se capturará el error
}
}, 1000);


Para manejar errores en código asíncrono, puedes utilizar las promesas (Promises) y su método catch.

Manejo de Errores en Promesas

Las promesas son un patrón de programación asíncrona que te permite manejar errores de forma más elegante. El método catch se utiliza para capturar errores que se produzcan dentro de una promesa.

«`javascript
function fetchData() {
return new Promise((resolve, reject) => {
// Simulación de una solicitud a una API
setTimeout(() => {
reject(new Error(«Error al obtener datos»));
}, 1000);
});
}

fetchData()
.then(data => {
console.log(«Datos obtenidos:», data);
})
.catch(error => {
console.error(«Error:», error.message);
});
«`

Tipos de Errores en JavaScript

JavaScript define varios tipos de errores comunes, incluyendo:

• RangeError: Se produce cuando un valor está fuera del rango permitido.

javascript
try {
let array = [1, 2, 3];
console.log(array[5]); // Índice fuera de rango
} catch (error) {
console.error("Error:", error.message);
}


• ReferenceError: Se produce cuando se hace referencia a una variable que no está definida.

javascript
try {
console.log(myVariable); // myVariable no está definida
} catch (error) {
console.error("Error:", error.message);
}


• TypeError: Se produce cuando se utiliza un operador o una función en un tipo de datos que no es compatible.

javascript
try {
let number = 10;
console.log(number + "Hola"); // Tipo de datos incompatible
} catch (error) {
console.error("Error:", error.message);
}


• URIError: Se produce cuando se utiliza una URI inválida.

javascript
try {
decodeURIComponent("%"); // URI inválida
} catch (error) {
console.error("Error:", error.message);
}


Conclusión

La sentencia try...catch es una herramienta indispensable para manejar errores en JavaScript. Permite que tu código se ejecute de forma estable y que tu aplicación responda a errores de forma controlada, evitando que se bloquee. La comprensión de su funcionamiento y la aplicación de prácticas sólidas de manejo de errores son esenciales para construir aplicaciones web robustas y fiables.