Cómo manejar errores en promesas en JavaScript

Introducción

Las promesas en JavaScript son una poderosa herramienta para manejar operaciones asíncronas. Sin embargo, es crucial manejar adecuadamente los errores que pueden ocurrir durante estas operaciones. En este artículo, aprenderemos cómo manejar errores en promesas en JavaScript.

Uso del método `catch`

El método más común para manejar errores en promesas es usando catch(). Este método captura cualquier error que ocurra en la promesa anterior y nos permite manejarlo adecuadamente.

// Ejemplo de uso de catch
let promesa = new Promise((resolve, reject) => {
    let exito = false;
    if (exito) {
        resolve("Operación exitosa");
    } else {
        reject("Ocurrió un error");
    }
});

promesa
    .then((mensaje) => {
        console.log(mensaje);
    })
    .catch((error) => {
        console.error(error); // "Ocurrió un error"
    });

Encadenamiento de `then` y manejo de errores

En las promesas encadenadas, es importante manejar los errores en cada paso del encadenamiento. Puedes hacerlo añadiendo un catch al final del encadenamiento o manejando errores en cada then.

// Ejemplo de encadenamiento con manejo de errores
let promesa = new Promise((resolve, reject) => {
    resolve("Primera promesa resuelta");
});

promesa
    .then((mensaje) => {
        console.log(mensaje);
        return new Promise((resolve, reject) => {
            reject("Error en la segunda promesa");
        });
    })
    .then((mensaje) => {
        console.log(mensaje);
    })
    .catch((error) => {
        console.error("Capturado en el catch:", error); // "Error en la segunda promesa"
    });

Uso de `async` y `await` con manejo de errores

Cuando se utilizan async y await para trabajar con promesas, los errores se pueden manejar utilizando bloques try...catch.

// Ejemplo de uso de async/await con manejo de errores
async function manejarErroresAsync() {
    try {
        let mensaje = await promesaConExito();
        console.log(mensaje);
        mensaje = await promesaConError();
        console.log(mensaje);
    } catch (error) {
        console.error("Error capturado con try...catch:", error);
    }
}

function promesaConExito() {
    return new Promise((resolve) => {
        resolve("Operación exitosa");
    });
}

function promesaConError() {
    return new Promise((resolve, reject) => {
        reject("Ocurrió un error en promesaConError");
    });
}

manejarErroresAsync();

Conclusión

Manejar errores en promesas es esencial para crear aplicaciones robustas y evitar que errores no controlados afecten la experiencia del usuario. Ya sea utilizando catch(), manejando errores en promesas encadenadas, o usando async y await con bloques try...catch, JavaScript ofrece varias formas de manejar errores en promesas de manera efectiva.