Manejo de errores en TypeScript: try/catch y más allá: de la A a la Z

Manejo de errores en TypeScript: desde try/catch hasta escenarios complejos

TypeScript, al ser una extensión de JavaScript, hereda y amplía los mecanismos de manejo de errores. El manejo correcto de excepciones es la clave para una aplicación estable y predecible. En este artículo, analizaremos todos los aspectos del trabajo con errores: desde el básico try/catch hasta la creación de clases de error tipadas propias y estrategias avanzadas.

Sintaxis básica: try, catch, finally

El mecanismo principal para el manejo de errores en TypeScript (como en JavaScript) es la construcción try...catch...finally. Permite interceptar excepciones que ocurren en el código y reaccionar ante ellas.

function parseJSON(data: string): object {    try {        return JSON.parse(data);    } catch (error) {        console.error('Error al analizar JSON:', error);        return {};    }}

parseJSON('{"name": "TypeScript"}'); // { name: 'TypeScript' }parseJSON('JSON no válido');        // {} (error interceptado)

El bloque finally se ejecuta en cualquier caso, tanto después de la finalización exitosa de try como después de interceptar un error. Es el lugar ideal para la limpieza de recursos (cerrar archivos, conexiones).

function processData(data: string): void {    let resource: any = null;    try {        resource = acquireResource();        // ... código peligroso    } catch (error) {        console.error('Error de procesamiento:', error);    } finally {        if (resource) {            resource.release(); // limpieza garantizada        }    }}

Tipado de errores: el problema de unknown

Una característica clave de TypeScript es que en el bloque catch, la variable error tiene por defecto el tipo unknown (a partir de TS 4.0). Esto se hizo intencionalmente para obligar al desarrollador a verificar explícitamente el tipo de error, en lugar de asumir que es Error.

try {    // algún código} catch (error) {    // error tiene tipo unknown    // Error: la propiedad 'message' no existe en el tipo 'unknown'    // console.log(error.message);

    // Enfoque correcto: verificar el tipo    if (error instanceof Error) {        console.log('Mensaje:', error.message);    } else {        console.log('Error desconocido:', error);    }}

¿Por qué es importante? En JavaScript, en el bloque catch puede caer cualquier cosa: una cadena, un número, un objeto, null o incluso undefined. La verificación forzada del tipo protege contra errores en tiempo de ejecución.

Creación de clases de error personalizadas

Para aplicaciones complejas, a menudo se requiere distinguir entre tipos de errores. En TypeScript, es fácil crear una jerarquía de clases de error propias que extiendan el Error incorporado.

// Clase base para errores de la aplicaciónclass AppError extends Error {    public readonly statusCode: number;    public readonly isOperational: boolean;

    constructor(message: string, statusCode: number = 500, isOperational: boolean = true) {        super(message);        this.name = this.constructor.name;        this.statusCode = statusCode;        this.isOperational = isOperational;

        // Restaurar el prototipo (importante para instanceof)        Object.setPrototypeOf(this, new.target.prototype);    }}

// Tipos de error específicosclass ValidationError extends AppError {    public readonly field: string;

    constructor(message: string, field: string) {        super(message, 400);        this.field = field;    }}

class NotFoundError extends AppError {    constructor(message: string = 'Recurso no encontrado') {        super(message, 404);    }}

// Usofunction getUser(id: number): User {    if (id <= 0) {        throw new ValidationError('El ID debe ser un número positivo', 'id');    }    // ... búsqueda de usuario    throw new NotFoundError