¿Qué es una Promesa?

Una promesa en JavaScript es un mecanismo para manejar operaciones asíncronas, abordando el problema de los callbacks anidados (callback hell). Semánticamente, una promesa es un objeto que representa el resultado eventual de una operación asíncrona.

Estados de una Promesa

Una promesa en JavaScript puede estar en uno de estos estados fundamentales:

• pendiente (pending): Estado inicial, la operación aún no ha concluido.
• resuelta (fulfilled): La operación se completó con éxito.
• rechazada (rejected): La operación falló.

El estado solo puede cambiar de pendiente a resuelta o de pendiente a rechazada. Una vez que el estado cambia, se mantiene inalterable, por lo que una promesa no puede ser cancelada.

Uso básico de una Promesa

En ES6, una promesa se crea utilizando el constructor Promise, que recibe una función con dos parámetros: resolve y reject.

const tareaAsincrona = new Promise(function(confirmar, rechazar) {
    // Simular una operación asíncrona
    const exito = true;
    const datos = "resultado obtenido";
    const errorFallo = "fallo en la operación";

    if (exito) {
        confirmar(datos);
    } else {
        rechazar(errorFallo);
    }
});

La función resolve (o confirmar en el ejemplo) cambia el estado a resuelta y pasa el valor de éxito. La función reject (o rechazar) cambia el estado a rechazada y transmite el error.

Métodos de instancia de una Promesa

then()

El método then adjunta callbacks para manejar los estados resuelto y rechazado. Devuelve una nueva promesa, permitiendo la encadenación.

tareaAsincrona.then(
    function(valor) {
        console.log("Éxito:", valor); // Se ejecuta si la promesa se resuelve
    },
    function(err) {
        console.log("Error:", err); // Se ejecuta si la promesa se rechaza
    }
);

catch()

El método catch es un atajo para manejar errores. Captura cualquier rechazo en la cadena de promesas.

tareaAsincrona
    .then(resultado => console.log("Datos:", resultado))
    .catch(error => console.log("Fallo detectado:", error));

Los errores se propagan hacia atrás hasta ser capturados, similar al manejo de excepciones síncronas.

finally()

El método finally ejecuta un callback sin importar el resultado final de la promesa, útil para limpieza o acciones comunes.

tareaAsincrona.finally(() => console.log("Operación finalizada, independientemente del resultado."));

Métodos estáticos de Promise

Promise.all()

Promise.all toma un arreglo de promesas y devuelve una nueva promesa que se reuselve cuando todas las promesas en el arreglo se resuelven, o se rechaza si alguna falla.

const promesaA = new Promise((res) => setTimeout(() => res("dato A"), 100));
const promesaB = new Promise((res) => setTimeout(() => res("dato B"), 200));
const promesaC = new Promise((_, rej) => setTimeout(() => rej("error C"), 150));

Promise.all([promesaA, promesaB, promesaC])
    .then(resultados => console.log("Todos completados:", resultados))
    .catch(err => console.log("Al menos una falló:", err)); // Salida: error C

El orden de los resultados en el arreglo coincide con el orden de las promesas de entrada, lo cual es útil para mantener la secuencia.

Promise.race()

Promise.race devuelve una promesa que se resuelve o rechaza tan pronto como una de las promesas en el arreglo lo haga, independientemente de si es éxito o fallo.

const rapido = new Promise((res) => setTimeout(() => res("rapido completado"), 50));
const lento = new Promise((res) => setTimeout(() => res("lento completado"), 200));

Promise.race([rapido, lento])
    .then(valor => console.log("Primera en terminar:", valor)); // Salida: rapido completado