Aprender TypeScript Manejo de errores

Manejo de errores en TypeScript

El manejo de errores en TypeScript va más allá de los mecanismos básicos de JavaScript. La combinación del sistema de tipos con estrategias modernas de gestión de errores permite crear aplicaciones más robustas y predecibles, donde los fallos se convierten en información tipada en lugar de excepciones imprevisibles.

Tipado de errores con catch

En TypeScript, el parámetro de un bloque catch tiene por defecto el tipo unknown (en modo estricto), lo que obliga a verificar el tipo antes de acceder a sus propiedades. Este comportamiento seguro previene errores de acceso a propiedades en objetos desconocidos.

try {
    const datos = JSON.parse(input);
} catch (error) {
    // error es unknown en TypeScript estricto
    if (error instanceof Error) {
        console.error(error.message); // ✓ Seguro
    }
}

Clases de error personalizadas

Crear clases de error tipadas permite distinguir diferentes categorías de fallos de forma explícita, mejorando la legibilidad y el mantenimiento del código.

class ErrorAPI extends Error {
    constructor(
        public readonly statusCode: number,
        message: string
    ) {
        super(message);
        this.name = "ErrorAPI";
    }
}

class ErrorValidacion extends Error {
    constructor(public readonly campo: string, message: string) {
        super(message);
        this.name = "ErrorValidacion";
    }
}

Patrón Result para errores tipados

El patrón Result (similar a Rust y lenguajes funcionales) permite representar resultados exitosos y errores como un tipo discriminado, eliminando las excepciones como mecanismo de flujo principal.

type Resultado<T, E extends Error = Error> =
    | { exito: true; valor: T }
    | { exito: false; error: E };

function dividir(a: number, b: number): Resultado<number> {
    if (b === 0) return { exito: false, error: new Error("División por cero") };
    return { exito: true, valor: a / b };
}

const resultado = dividir(10, 2);
if (resultado.exito) {
    console.log(resultado.valor); // TypeScript sabe que es number
}

Narrowing de errores y discriminated unions

Los discriminated unions son especialmente potentes para modelar estados de error en aplicaciones, proporcionando exhaustividad garantizada por el compilador.

type EstadoPeticion<T> =
    | { estado: "cargando" }
    | { estado: "exito"; datos: T }
    | { estado: "error"; mensaje: string; codigo: number };