Manejo de errores en TypeScript

Este artículo explica el manejo de errores en TypeScript.

YouTube Video

Manejo de errores en TypeScript

El manejo de errores en TypeScript se realiza fundamentalmente utilizando la estructura try...catch, al igual que en JavaScript. En TypeScript, es posible gestionar el contenido del error de manera más clara mediante la inferencia de tipos. Esto permite un manejo de errores más preciso y legible.

Sintaxis de try...catch

La sintaxis básica para el manejo de errores es la siguiente:.

 1try {
 2    // Code that may throw an error
 3    throw new Error("Something went wrong!");
 4} catch (error) {
 5    // Catch and handle the error
 6    console.error("Error:", error);
 7} finally {
 8    // Code that runs regardless of whether an error occurred
 9    console.log("Finally block executed.");
10}

Manejo de errores con seguridad de tipos

En TypeScript, los errores capturados dentro de un bloque catch se tratan como de tipo any, pero se recomienda especificar el tipo adecuado para un manejo de errores más seguro. Por ejemplo, puedes definir y usar un tipo de error personalizado de la siguiente manera:.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Invalid operation", 400);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    } else {
14        console.error("Unknown error occurred");
15    }
16}

En este ejemplo, se crea una clase llamada CustomError y se lanza un error con propiedades personalizadas como errorCode. En el bloque catch, utiliza instanceof para determinar el tipo de error y realizar el manejo adecuado.

Manejo de errores asíncronos

En TypeScript, try...catch también se utiliza para manejar errores cuando se usan funciones asíncronas.

 1async function fetchData() {
 2    try {
 3        const response = await fetch("https://api.example.com/data");
 4        if (!response.ok) {
 5            throw new Error(`HTTP error! status: ${response.status}`);
 6        }
 7        const data = await response.json();
 8        console.log(data);
 9    } catch (error) {
10        console.error("Failed to fetch data:", error);
11    }
12}
13
14fetchData();

En este ejemplo, se obtienen datos utilizando fetch y se verifica response.ok para lanzar un error si el código de estado no es OK. El error se captura en catch y se genera el registro adecuado.

Resumen

En TypeScript, usar tipos para aclarar el contenido de los errores hace que el manejo de errores sea más seguro y legible. Al manejar errores, es importante aclarar qué tipos de errores pueden ocurrir y manejarlos en consecuencia.

Error

La clase Error en TypeScript extiende la clase Error en JavaScript y es un objeto básico para representar errores. Al usar la clase Error, puedes crear un objeto que incluye un mensaje de error y realizar el manejo de errores.

Conceptos básicos de la clase Error

La clase Error se utiliza de la siguiente manera.

1const error = new Error("Something went wrong!");
2console.log(error.message); // "Something went wrong!"
3console.log(error.name);    // "Error"

Propiedades

La clase Error tiene las siguientes propiedades:.

• mensaje Una cadena que representa el mensaje de error.
• nombre El nombre del error. Por defecto, es "Error", pero puede cambiarse creando una clase de error personalizada.
• pila Información de rastreo de pila utilizada para la depuración. Una cadena que indica qué código causó el error cuando ocurrió.

Clase de Error Personalizada

También es posible extender la clase Error y crear tus propias clases de error. Esto es útil en situaciones donde se requiere un manejo específico de errores. Por ejemplo, es efectivo cuando se desea manejar diferentes tipos de errores como errores en solicitudes HTTP o errores de base de datos.

Ejemplo de Creación de un Error Personalizado

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message); // Call the constructor of the parent class 'Error'
 4        this.name = "CustomError"; // Set the name of the error
 5    }
 6}
 7
 8const customError = new CustomError("Invalid operation", 400);
 9console.log(customError.message);   // "Invalid operation"
10console.log(customError.name);      // "CustomError"
11console.log(customError.errorCode); // 400

• Al crear una clase CustomError y añadir información como códigos de error, puedes gestionar información más completa sobre los errores.

Herencia de la Clase Error

En TypeScript, al crear una clase de error personalizada extendiendo la clase Error, hay algunos puntos a tener en cuenta.

1. Llamando a super() En el constructor de una clase de error personalizada, debes llamar a super() para invocar el constructor de la clase Error. Esto asegura que las propiedades message y stack estén correctamente inicializadas.

2. Agregando propiedades Si deseas añadir información adicional al objeto de error, define nuevas propiedades dentro de la clase. Por ejemplo, en el CustomError anterior, se añade una propiedad errorCode.

Lanzar y Capturar Errores

Puedes manejar errores lanzando errores usando la clase Error o una clase de error personalizada y luego capturándolos.

 1function riskyOperation() {
 2    throw new Error("Something went wrong during the operation");
 3}
 4
 5try {
 6    riskyOperation();
 7} catch (error) {
 8    if (error instanceof Error) {
 9        console.error(error.message);  // "Something went wrong during the operation"
10        console.error(error.name);     // "Error"
11    }
12}

En el caso de errores personalizados, también usa instanceof para identificar errores específicos y manejarlos adecuadamente.

 1class CustomError extends Error {
 2    constructor(message: string, public errorCode: number) {
 3        super(message);
 4        this.name = "CustomError";
 5    }
 6}
 7
 8try {
 9    throw new CustomError("Database connection failed", 500);
10} catch (error) {
11    if (error instanceof CustomError) {
12        console.error(`Error: ${error.message}, Code: ${error.errorCode}`);
13    }
14}

Resumen

La clase Error en TypeScript es una clase fundamental para realizar el manejo estándar de errores. Además, al extender la clase Error para crear errores personalizados, se vuelve posible un manejo de errores flexible basado en tipos de error e información adicional.

Puedes seguir el artículo anterior utilizando Visual Studio Code en nuestro canal de YouTube. Por favor, también revisa nuestro canal de YouTube.

YouTube Video