Manejo de Errores en JavaScript

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

YouTube Video

Manejo de Errores en JavaScript

El manejo de errores en JavaScript es una característica importante para capturar y manejar adecuadamente los errores cuando un programa se encuentra con problemas inesperados. Principalmente, es común utilizar la sintaxis try...catch para capturar y manejar errores. Además, al trabajar con Promesas u operaciones asíncronas, el manejo de errores también se puede realizar utilizando async/await o Promise.prototype.catch.

Sintaxis try...catch

try...catch se utiliza para capturar y manejar errores cuando ocurren dentro de un bloque de código.

 1try {
 2    // Code that may throw an error
 3    let result = riskyFunction();
 4    console.log(result);
 5} catch (error) {
 6    // Catch and handle the error
 7    console.error("An error occurred:", error.message);
 8} finally {
 9    // Code that will always execute
10    console.log("Error handling has completed.");
11}

• Si ocurre un error dentro de un bloque try, la ejecución del programa se interrumpe y se ejecuta el bloque catch.
• El bloque finally siempre se ejecuta, independientemente de si hay un error o no. Es útil para liberar recursos y realizar un procesamiento final, entre otras cosas.

Lanzando Errores (throw)

En JavaScript, puedes provocar un error explícitamente utilizando la palabra clave throw. Se utiliza para lanzar mensajes de error personalizados o errores personalizados.

 1function checkAge(age) {
 2    if (age < 18) {
 3        throw new Error("You are under 18 years old.");
 4    }
 5    return "Age verification completed.";
 6}
 7
 8try {
 9    let result = checkAge(15);
10    console.log(result);
11} catch (error) {
12    console.error(error.message);  // Displays "You are under 18 years old."
13}

Manejo de Errores en Operaciones Asincrónicas (Promise y async/await)

Al realizar operaciones asíncronas, el manejo de errores es ligeramente diferente. Al utilizar Promesas, los errores se capturan con el método catch.

1let promise = new Promise((resolve, reject) => {
2    // Asynchronous operation
3    setTimeout(() => reject(new Error("An issue has occurred!")), 1000);
4});
5
6promise
7    .then(result => console.log(result))
8    .catch(error => console.error(error.message));  // Displays "An issue has occurred!"

Cuando realizas operaciones asíncronas utilizando async/await, puedes manejar los errores con try...catch.

 1async function fetchData() {
 2    try {
 3        let response = await fetch('https://api.example.com/data');
 4        let data = await response.json();
 5        console.log(data);
 6    } catch (error) {
 7        console.error("An error occurred while fetching data:", error.message);
 8    }
 9}
10
11fetchData();

Resumen

• Puedes capturar errores sincrónicos utilizando la sintaxis try...catch.
• Puedes lanzar tus propios errores utilizando throw.
• Los errores en operaciones asíncronas se pueden manejar utilizando el método catch de Promise, o con async/await y try...catch.

Al utilizar estos métodos, puedes asegurarte de que tu programa funcione correctamente incluso cuando ocurren errores.

Error

La clase Error se utiliza para el manejo de errores. Proporciona la capacidad de crear errores y suministrar mensajes de error y trazas de pila.

1try {
2    throw new Error("Something went wrong");
3} catch (e) {
4    console.log(e.message); // Something went wrong
5}

Uso básico

Un objeto Error se puede crear explícitamente cuando ocurre un error. Creas una instancia con new Error() y pasas un mensaje de error.

1const error = new Error("Something went wrong");
2console.log(error.message);  // "Something went wrong"
3console.log(error.name);     // "Error"
4console.log(error.stack);    // Stack trace (information about where the error occurred)

Lanzando Errores con throw

En JavaScript, puedes lanzar un error utilizando la palabra clave throw. Esto se utiliza para interrumpir el procesamiento en situaciones específicas y pasar el control a un manejador de errores.

1function doSomething() {
2    throw new Error("This function is not yet implemented");
3}
4
5try {
6    doSomething();
7} catch (e) {
8    console.error(e.message);  // "This function is not yet implemented"
9}

Los errores lanzados con throw se pueden capturar usando la sintaxis try...catch.

Creación de Errores Personalizados

En JavaScript, puedes crear tus propios errores personalizados extendiendo la clase Error. Esto te permite crear errores adaptados a situaciones específicas.

 1class CustomError extends Error {
 2    constructor(message) {
 3        super(message);  // Call the parent class constructor
 4        this.name = "CustomError";  // Set the error name
 5    }
 6}
 7
 8try {
 9    throw new CustomError("A custom error has occurred");
10} catch (e) {
11    console.error(e.name);    // "CustomError"
12    console.error(e.message); // "A custom error has occurred"
13}

Clases de Error Integradas

JavaScript tiene varias clases de errores integradas que extienden la clase Error. Estas se utilizan para representar errores específicos.

• ReferenceError: Ocurre cuando haces referencia a una variable que no existe.
• TypeError: Ocurre cuando el tipo de un valor es diferente del tipo esperado.
• RangeError: Ocurre cuando un número está fuera del rango permitido.
• SyntaxError: Ocurre cuando se ejecuta código que no es sintácticamente correcto.
• EvalError: Errores relacionados con el uso de la función eval(). Rara vez se utiliza en la actualidad.
• URIError: Ocurre cuando se utiliza un URI inválido (errores de codificación o decodificación).

Ejemplo: ReferenceError

Aquí tienes un ejemplo de un ReferenceError.

1try {
2    console.log(undefinedVariable);  // Undefined variable
3} catch (e) {
4    console.error(e.name);    // "ReferenceError"
5    console.error(e.message); // "undefinedVariable is not defined"
6}

Ejemplo: TypeError

Aquí tienes un ejemplo de un TypeError.

1try {
2    null.f();  // Attempting to call a function on null
3} catch (e) {
4    console.error(e.name);    // "TypeError"
5    console.error(e.message); // "Cannot read properties of null (reading 'f')"
6}

Bloque finally

En la sintaxis try...catch, utiliza el bloque finally para operaciones que quieras ejecutar independientemente de si ocurre un error.

1try {
2    throw new Error("An issue has occurred");
3} catch (e) {
4    console.error(e.message);  // "An issue has occurred"
5} finally {
6    console.log("Performing cleanup");
7}

En este ejemplo, las operaciones en el bloque finally se ejecutan incluso si se lanza un error.

Propiedades del objeto Error

El objeto Error tiene las siguientes propiedades.

• message: Este es el mensaje del error.
• name: El nombre del error, que por defecto es "Error".
• stack: Un seguimiento de pila que contiene dónde ocurrió el error, útil para la depuración.

Beneficios del manejo de excepciones

Implementando correctamente el manejo de errores, puedes evitar que la aplicación se cierre cuando ocurra un comportamiento inesperado. Al utilizar adecuadamente la sintaxis try...catch y los objetos de error, puedes escribir código más robusto.

 1function divide(a, b) {
 2    if (b === 0) {
 3        throw new Error("Cannot divide by zero");
 4    }
 5    return a / b;
 6}
 7
 8try {
 9    console.log(divide(4, 0));  // An error will occur
10} catch (e) {
11    console.error(e.message);   // "Cannot divide by zero"
12}

Resumen

• La clase Error se utiliza para representar una causa de error y realizar el manejo de errores.
• Usa la sintaxis try...catch...finally para manejar errores y prevenir la terminación inesperada de la aplicación.
• También es posible extender la clase Error para crear errores personalizados.
• Puede manejar varios tipos de errores utilizando clases de error integradas como TypeError y ReferenceError.

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