Manejo de errores en TypeScript: try/catch y métodos avanzados

Manejo de errores en TypeScript: de try/catch a código robusto

TypeScript agrega tipado estático a JavaScript, pero los errores en tiempo de ejecución siguen siendo una parte esencial del desarrollo. Un manejo incorrecto de excepciones puede provocar caídas de la aplicación, fugas de datos o un funcionamiento incorrecto de la interfaz de usuario. En este artículo analizaremos cómo manejar errores de manera efectiva en TypeScript, utilizando mecanismos integrados y patrones avanzados.

Try/catch básico en TypeScript

La construcción try/catch es la base del manejo de errores. En TypeScript, a diferencia de JavaScript, podemos tipificar el error capturado. Sin embargo, hay un matiz importante: por defecto, el tipo de error en el bloque catch es unknown, no Error.

try {    const data = JSON.parse('json inválido');    console.log(data);} catch (error) {    // error tiene tipo unknown    if (error instanceof Error) {        console.error('Ocurrió un error:', error.message);    } else {        console.error('Error desconocido:', error);    }}

¿Por qué es importante esto? En JavaScript se puede lanzar cualquier cosa: un string, un número, un objeto. TypeScript nos protege del acceso inseguro a las propiedades del error sin verificación. Se recomienda siempre verificar el tipo de error antes de usarlo.

Clases de error personalizadas

Para un manejo más preciso, cree sus propias clases de error que extiendan el Error incorporado. Esto permite distinguir tipos de errores y transmitir información adicional.

class ValidationError extends Error {    constructor(        public field: string,        message: string    ) {        super(message);        this.name = 'ValidationError';    }}

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

function processUserData(data: unknown): void {    if (!data || typeof data !== 'object') {        throw new ValidationError('data', 'Datos incorrectos');    }        if (!('email' in data)) {        throw new ValidationError('email', 'Email es obligatorio');    }}

try {    processUserData({ name: 'Iván' });} catch (error) {    if (error instanceof ValidationError) {        console.error(`Error de validación del campo ${error.field}: ${error.message}`);    } else if (error instanceof NetworkError) {        console.error(`Error de red ${error.statusCode}: ${error.message}`);    } else {        console.error('Error desconocido:', error);    }}

Este enfoque hace que el código sea autodocumentado y simplifica la depuración. Siempre sabrá dónde y por qué ocurrió el error.

Tipificación de funciones con errores: never y discriminated unions

TypeScript proporciona herramientas potentes para trabajar con errores a nivel de tipos. Use el tipo never para funciones que siempre lanzan una excepción, y discriminated unions para devolver errores.

function throwError(message: string): never {    throw new Error(message);}

// Discriminated union para el resultadotype Result<T> =     | { success: true; data: T }    | { success: false; error: string };

function fetchUser(id: number): Result<{ name: string }> {    try {        // Simulación de solicitud        if (id <= 0) {            return { success: false, error: 'ID incorrecto' };        }        return { success: true, data: { name: 'Ana' } };    } catch (error) {        return { success: false, error: 'Error de red' };    }}

const result = fetchUser(1);if (result.success) {    console.log('Usuario:', result.data.name);} else {    console.error('Error:', result.error);}

El patrón Result permite evitar excepciones implícitas y hace que el manejo de errores sea más explícito y seguro.