TypeScript Manejo de Errores

El manejo de errores es una parte importante para garantizar la robustez del programa.

TypeScript proporciona un potente sistema de tipos que puede ayudar a los desarrolladores a manejar y prevenir errores de manera más efectiva.

Este artículo presenta los patrones comunes de manejo de errores y las mejores prácticas en TypeScript.


Diagrama SVG: Métodos de manejo de errores Fondo Título Métodos de manejo de errores Método 1: try-catch try-catch try { // Código que puede fallar } catch (e) { // Manejar el error } Capturar y manejar excepciones Método 2: Tipo Result Tipo Result type Result = | { ok: true; value: T } | { ok: false; error: E } Devolver un resultado en lugar de lanzar una excepción Método 3: Tipos de error Errores personalizados class AppError extends Error { code: string; } Información de error estructurada Parte inferior Mejores prácticas Práctica 1 Definir tipos de error claros Práctica 2 Centralizar el manejo de errores Práctica 3 Evitar fugas de excepciones

¿Por qué se necesita un buen manejo de errores?

Cualquier programa puede encontrar situaciones de error, como fallos en solicitudes de red, archivos inexistentes, errores de entrada del usuario, etc.

Un buen manejo de errores puede evitar que el programa se bloquee, proporcionar mensajes de error amigables y ayudar a los desarrolladores a localizar problemas.

El sistema de tipos de TypeScript puede detectar problemas potenciales en la fase de compilación, reduciendo los errores en tiempo de ejecución.

Explicación del concepto:Hay dos formas principales de manejo de errores: el manejo de excepciones (try-catch) y el manejo mediante valores de retorno (tipo Result). El primero utiliza el lanzamiento de excepciones para indicar errores, mientras que el segundo utiliza el valor de retorno para transportar la información del error.


Tipos de error personalizados

Al extender la clase Error para crear tipos de error personalizados, se puede transportar más información del error.

Esto hace que el manejo de errores sea más preciso y estructurado.

Ejemplo

// Definir la clase de error de la aplicación
// Extender la clase Error incorporada y agregar un código de error
class AppError extends Error {
    // Código de error, utilizado para el manejo programático de errores
    code: string;

    // Constructor
    constructor(message: string, code: string) {
        super(message);  // Llamar al constructor de la clase padre
        this.name = "AppError";  // Establecer el nombre del error
        this.code = code;  // Guardar el código de error
    }
}

// Función de división segura
function divide(a: number, b: number): number {
    // Verificar si el divisor es cero
    if (b === 0) {
        // Lanzar un error personalizado
        throw new AppError("Cannot divide by zero", "DIVIDE_BY_ZERO");
    }
    return a / b;
}

// Usar try-catch para capturar el error
try {
    var result = divide(10, 0);
} catch (error) {
    // Verificar el tipo de error
    if (error instanceof AppError) {
        console.log("Error de aplicación: " + error.message + ", Código: " + error.code);
    } else {
        console.log("Error desconocido: " + error);
    }
}

Resultado de la ejecución:

应用错误: Cannot divide by zero, 代码: DIVIDE_BY_ZERO

Código de error:Agregar códigos a los errores puede ayudar al programa a manejar diferentes tipos de errores con mayor precisión.


El tipo Result evita excepciones

Otra forma de manejo de errores es utilizar el tipo Result.

Transporta la información del error a través del valor de retorno, en lugar de lanzar excepciones. Este enfoque es común en la programación funcional.

Ejemplo

// Definir el tipo Result usando un tipo unión
// En caso de éxito contiene ok: true y el valor; en caso de fallo contiene ok: false y el error
type Result<T, E = Error> =
    | { ok: true; value: T }
    | { ok: false; error: E };

// Función de división que utiliza el tipo Result
function safeDivide(a: number, b: number): Result<number, string> {
    // Verificar si el divisor es cero
    if (b === 0) {
        // Devolver un resultado de error
        return { ok: false, error: "Cannot divide by zero" };
    }
    // Devolver un resultado de éxito
    return { ok: true, value: a / b };
}

// Llamar a la función y manejar el resultado
var result = safeDivide(10, 2);

// Procesar según el tipo de resultado
if (result.ok) {
    console.log("Resultado: " + result.value);
} else {
    console.log("Error: " + result.error);
}

Resultado de la ejecución:

结果: 5

Ventajas:El tipo Result hace que el manejo de errores sea explícito; el llamador debe manejar los posibles errores y no puede ignorarlos.


Manejo de errores en funciones asíncronas

En las funciones asíncronas, el manejo de errores es especialmente importante.

Se puede usar try-catch o el tipo Result para manejar errores en operaciones asíncronas.

Ejemplo

// Definir la interfaz de usuario
interface User {
    id: number;
    name: string;
}

// Función asíncrona simulada para obtener un usuario
async function fetchUser(id: number): Promise<Result<User, Error>> {
    try {
        // Simular una solicitud de red
        var response = await fetch("/api/users/" + id);
        var user = await response.json();
        // Devolver un resultado de éxito
        return { ok: true, value: user };
    } catch (error) {
        // Devolver un resultado de error
        return { ok: false, error: error as Error };
    }
}

// Función principal
async function main() {
    // Llamar a la función asíncrona
    var result = await fetchUser(1);

    // Manejar el resultado
    if (result.ok) {
        console.log("Usuario: " + JSON.stringify(result.value));
    } else {
        console.log("Error: " + result.error.message);
    }
}

// Ejecutar la función principal
main();

Resultado de la ejecución:

Usuario: {"id":1,"name":"Alice"}

Sugerencia:El try-catch en una función asíncrona captura cualquier error lanzado por la expresión await.


Encapsulamiento genérico del manejo de errores

Se puede crear una función genérica de manejo de errores para simplificar el manejo de errores en código asíncrono.

Ejemplo

// Función envoltorio genérica para el manejo de errores
// Acepta una función asíncrona y devuelve un tipo Result
async function withErrorHandling<T>(
    fn: () => Promise<T>
): Promise<Result<T, Error>> {
    try {
        // Ejecutar la función asíncrona pasada
        var data = await fn();
        // Devolver un resultado de éxito
        return { ok: true, value: data };
    } catch (error) {
        // Devolver un resultado de error
        return { ok: false, error: error as Error };
    }
}

// Usar el manejo de errores genérico
// Simular la obtención de datos
var result = await withErrorHandling(async function() {
    var response = await fetch("/api/data");
    return response.json();
});

// Manejar según el resultado
if (result.ok) {
    console.log("Datos: " + JSON.stringify(result.value));
} else {
    console.error("Error:", result.error);
}

Mejores prácticas:Encapsular la lógica genérica de manejo de errores puede reducir la duplicación de código y mejorar la mantenibilidad del código.


Precauciones

  • No ignores los errores:No uses bloques catch vacíos para capturar e ignorar errores
  • Define tipos de error claros:Intenta usar tipos de error específicos en lugar del Error genérico
  • Límites de error:Establece un mecanismo unificado de manejo de errores en la aplicación
  • No abuses de las excepciones:Para errores previsibles, prioriza el uso de valores de retorno en lugar de lanzar excepciones

Recomendación:Elige el método de manejo de errores según el escenario: usa excepciones para errores de programa y Result para errores de negocio.


Resumen

Un buen manejo de errores es la base para construir aplicaciones robustas.

  • Errores personalizados:Extiende la clase Error y agrega información como códigos de error
  • Tipo Result:Maneja errores mediante valores de retorno para evitar excepciones
  • async/await:Usa try-catch para manejar errores asíncronos
  • Encapsulamiento de errores:Crea funciones genéricas de manejo de errores
  • Límites de error:Establece un mecanismo unificado de manejo de errores

Mejores prácticas:Elige el método de manejo de errores adecuado según el escenario específico, equilibrando la legibilidad y la robustez del código.


Otras extensiones