Gestión de excepciones con Try Catch

La gestión de errores es una parte fundamental en el desarrollo de software que nos permite detectar, manejar y corregir situaciones inesperadas o excepcionales durante la ejecución de un programa.

Un error, que también llamaremos EXCEPCION, es una condición anormal o inesperada que interrumpe el flujo normal de ejecución de un programa.

La gestión de errores forma parte de las estructuras de control de flujo porque modifican el procedimiento normal del programa. Bien sea intencionadamente o no.

Sea cual sea el motivo, lo importante es que ha ocurrido un error. Entonces el programa lanza un aviso de que ha ocurrido una anomalía. A este aviso generalmente lo llamamos EXCEPCION.

Si la excepción sigue “subiendo” todas entre llamadas hasta llegar a la función principal, le saltará un error al usuario. En este caso, lo normal es que el programa se bloquee y deje de funcionar (de hecho lo normal es que cierre abruptamente, “modo boom”).

Lanzamiento y captura de excepciones

En la mayoría de los lenguajes de programación, las excepciones se lanzan cuando ocurre un error mediante la instrucción throw (o similar).

throw new Exception("¡Esta es una excepción lanzada manualmente!");

Estas excepciones pueden ser capturadas y manejadas por otras partes del código utilizando bloques try-catch o try-catch-finally.

try
{
    // Código que puede lanzar una excepción 💣
}
catch (Exception ex)
{
    // Manejo de la excepción, salta solo si ocurre un error 💥
}
finally
{
	// Bloque final opcional, se ejecuta siempre, ocurra error 💥 o no 👍
}

Ejemplo de excepciones en distintos lenguajes

Vamos a ver cómo usar un bloque try-catch para capturar excepciones y manejarlas de manera controlada en distintos lenguajes, y cómo lanzar una Excepcion manualmente con throw (o similar).

Para el ejemplo vamos a usar simplemente dividir por cero, que es una operación no permitida que genera un error. Es un forma muy sencilla de forzar lanzar la excepción para el ejemplo.

// Ejemplo en C#
try
{
    // Código que puede lanzar una excepción
    int resultado = 10 / 0; // División por cero 💥
}
catch (Exception ex)
{
    // Manejo de la excepción
    Console.WriteLine("Error: " + ex.Message);
}

throw new Exception("¡Esta es una excepción lanzada manualmente!");

// Ejemplo en C++
try
{
    // Código que puede lanzar una excepción
    int resultado = 10 / 0; // División por cero 💥
}
catch (const std::exception& ex)
{
    // Manejo de la excepción
    std::cout << "Error: " << ex.what() << std::endl;
}

throw std::runtime_error("¡Esta es una excepción lanzada manualmente!");

// Ejemplo en JavaScript
try {
    // Código que puede lanzar una excepción
    let resultado = 10 / 0; // División por cero 💥
} catch (error) {
    // Manejo de la excepción
    console.log("Error: " + error.message);
}

 throw new Error("¡Esta es una excepción lanzada manualmente!");

# Ejemplo en Python
try:
    # Código que puede lanzar una excepción
    resultado = 10 / 0  # División por cero 💥
except ZeroDivisionError as ex:
    # Manejo de la excepción
    print("Error:", ex)

 raise Exception("¡Esta es una excepción lanzada manualmente!")

Como de costumbre, aparte de las pequeñas diferencias de sintaxis, la mayoría de lenguajes de programación incluyen gestión de Excepciones, con más similaridades que diferencias.

Buenas prácticas Consejos

No debéis abusar del uso del bloque try-catch. Su uso debe limitarse a situaciones realmente excepcionales o imprevisibles, y no como un mecanismo para controlar el flujo normal del programa.

Si en un proceso es previsible que ocurra un error, antes debemos comprobar las posibles causas de los errores. El bloque try-catch se queda únicamente para las cosas que no podemos comprobar.

Por ejemplo, imaginemos que quieres acceder a un fichero. La lectura de un fichero es un proceso que siempre es susceptible de generar Excepciones, porque es un recurso del sistema operativo que no controlamos nosotros.

try
{
	string contenido = File.ReadAllText(archivo);
	Console.WriteLine("Contenido del archivo: " + contenido);
}
catch (Exception ex)
{
	Console.WriteLine("Error durante la lectura del archivo: " + ex.Message);
}

Una posible causa es que el fichero no exista. Eso no es una Excepcion, es un motivo claro, evidente y conocido, de que no podamos leerlo. Por tanto, lo limpio es que hagamos esa comprobación previamente.

if (File.Exists(archivo))
{
	try
	{
		string contenido = File.ReadAllText(archivo);
		Console.WriteLine("Contenido del archivo: " + contenido);
	}
	catch (Exception ex)
	{
		Console.WriteLine("Error durante la lectura del archivo: " + ex.Message);
	}
}
else
{
	Console.WriteLine("El archivo no existe.");
}

Únicamente dejamos el try-catch para la lectura del fichero. Que puede ser susceptible de dar un error, incluso aunque el fichero exista. Esto ya es un imponderable o situación que no podemos preveer, y aquí es donde tiene sentido envolverlo en un try-catch.

Esto es así, en primer lugar, por limpieza. Pero, por otro lado, porque el try-catch tiene un impacto significativo en el rendimiento del programa. Así que únicamente debemos usarlo para lo que es, gestión de errores imprevistos. y no para todo.