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
¿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
// 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
// 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
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
// 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