En este módulo, exploraremos cómo manejar errores en TypeScript de manera eficiente. Veremos el uso de las estructuras clásicas de manejo de errores como try, catch y finally, cómo funciona el tipado de errores en TypeScript, y cómo crear excepciones personalizadas para adaptarse a las necesidades de tu aplicación.

---

7.1. Control de errores con try, catch y finally

El manejo de errores en TypeScript funciona de manera similar a JavaScript mediante el uso de bloques try, catch, y finally. Estos bloques te permiten capturar errores y reaccionar de manera apropiada cuando algo sale mal durante la ejecución de tu código.

• try: Contiene el código que puede lanzar un error.
• catch: Contiene el código para manejar el error si ocurre.
• finally: Se ejecuta siempre, tanto si ocurre un error como si no.

Ejemplo básico:

 
1function dividir(a: number, b: number): number {
2  if (b === 0) {
3    throw new Error("No se puede dividir por cero");
4  }
5  return a / b;
6}
7
8try {
9  console.log(dividir(10, 2));  // 5
10  console.log(dividir(10, 0));  // Error lanzado
11} catch (error) {
12  console.error("Error capturado:", error.message);
13} finally {
14  console.log("Operación completada.");
15}
Salida de Consola!:
5
Operación completada.
Error capturado: No se puede dividir por cero

En este ejemplo, cuando intentamos dividir por cero, se lanza un error que es capturado por el bloque catch. El bloque finally siempre se ejecuta, independientemente de si ocurrió o no un error.

7.2. Tipado de errores

En TypeScript, puedes asignar un tipo a los errores capturados en el bloque catch. Sin embargo, por defecto, TypeScript trata los errores como any, lo que significa que el error puede ser de cualquier tipo.

Ejemplo sin tipado de error:

 
1try {
2  throw "Un error inesperado";  // Puede ser cualquier cosa: string, number, objeto, etc.
3} catch (error) {
4  console.log("Error:", error);  // TypeScript asume que error es de tipo `any`
5}
Salida de Consola!:
Error: Un error inesperado

Para mejorar el tipado de errores, puedes especificar que el error es una instancia de Error, lo cual es la práctica más común.

Ejemplo con tipado de error:

 
1try {
2  throw new Error("Un error ocurrió");
3} catch (error) {
4  if (error instanceof Error) {
5    console.log("Mensaje de error:", error.message);  // Ahora TypeScript sabe que error tiene una propiedad `message`
6  }
7}
Salida de Consola!:
Mensaje de error: Un error ocurrió

El tipo Error es la clase base para todas las excepciones en JavaScript/TypeScript, e incluye propiedades como message, name, y stack.

Capturar errores de diferentes tipos:

 
1try {
2  // Algo que puede fallar
3  console.log("Ejecutando código...");
4} catch (error: unknown) {
5  if (error instanceof Error) {
6    console.log("Error:", error.message);  // Esto captura errores que son instancias de `Error`
7  } else {
8    console.log("Error desconocido");
9  }
10}
Salida de Consola!:
Ejecutando código...

Al usar el tipo unknown, estamos siendo más estrictos con el manejo de errores, asegurándonos de que solo tratamos los errores correctamente si son del tipo Error.

7.3. Creación de excepciones personalizadas

En TypeScript, es posible crear tus propias clases de excepciones personalizadas. Esto te permite crear errores específicos para tu aplicación, con mensajes y comportamiento adecuados para tu lógica de negocio.

Ejemplo de excepción personalizada:

 
1class DivisionPorCeroError extends Error {
2  constructor() {
3    super("No se puede dividir por cero");
4    this.name = "DivisionPorCeroError";
5  }
6}
7
8function dividir(a: number, b: number): number {
9  if (b === 0) {
10    throw new DivisionPorCeroError();
11  }
12  return a / b;
13}
14
15try {
16  console.log(dividir(10, 0));  // Lanza el error personalizado
17} catch (error) {
18  if (error instanceof DivisionPorCeroError) {
19    console.error("Error específico:", error.message);  // "Error específico: No se puede dividir por cero"
20  } else {
21    console.error("Error general:", error);
22  }
23}
Salida de Consola!:
Error general: Error [DivisionPorCeroError]: 
    No se puede dividir por cero

En este ejemplo, la clase DivisionPorCeroError extiende la clase base Error, proporcionando un mensaje de error personalizado y un nombre de error específico. Luego, lanzamos este error cuando se intenta dividir por cero y lo capturamos en el bloque catch.

Excepciones personalizadas con más detalles: Puedes agregar más propiedades a las excepciones personalizadas para proporcionar más información sobre el error.

 
1class ArchivoNoEncontradoError extends Error {
2  archivo: string;
3
4  constructor(archivo: string) {
5    super(`El archivo ${archivo} no fue encontrado`);
6    this.name = "ArchivoNoEncontradoError";
7    this.archivo = archivo;
8  }
9}
10
11function leerArchivo(ruta: string): void {
12  // Simulación de error si el archivo no existe
13  throw new ArchivoNoEncontradoError(ruta);
14}
15
16try {
17  leerArchivo("datos.txt");
18  console.log("Archivo leído correctamente");
19} catch (error) {
20  if (error instanceof ArchivoNoEncontradoError) {
21    console.error(`Error: ${error.message}, Archivo: ${error.archivo}`);
22  }
23}
Salida de Consola!:
Error: El archivo datos.txt no fue encontrado, Archivo: datos.txt

En este ejemplo, la clase ArchivoNoEncontradoError no solo proporciona un mensaje de error, sino que también incluye el nombre del archivo que no fue encontrado.

---

Resumen del Módulo 7

Este módulo te ha mostrado cómo manejar errores de manera efectiva en TypeScript. Aprendiste a utilizar try, catch, y finally para capturar y reaccionar a errores, cómo tipar errores para hacer el código más seguro, y cómo crear excepciones personalizadas que se adapten a las necesidades específicas de tu aplicación. El manejo de errores es una parte crucial de cualquier aplicación robusta, y el uso adecuado de estas herramientas te permitirá desarrollar sistemas más fiables.