Una promesa de valor futuro
Una promesa es un objeto que representa el resultado de una operación que todavía no terminó. Es como el ticket que te dan al pedir en un restaurante: aún no tienes la comida, pero tienes algo que te garantiza que, en algún momento, la recibirás o te dirán que no hay.
Una promesa siempre está en uno de tres estados:
| Estado | Significado |
|---|---|
| Pendiente (pending) | La operación sigue en curso. |
| Cumplida (fulfilled) | Terminó bien y tiene un valor. |
| Rechazada (rejected) | Falló y tiene un error. |
Cuando pasa de pendiente a cumplida o rechazada, ya no vuelve a cambiar.
Usar una promesa: then y catch
Muchas funciones modernas devuelven promesas; fetch, la función para pedir datos a un servidor, es la más conocida. Para usar el resultado, le pasas callbacks a sus métodos:
.then(valor => ...)se ejecuta cuando la promesa se cumple..catch(error => ...)se ejecuta cuando se rechaza..finally(() => ...)se ejecuta en ambos casos.
obtenerClima("Lima")
.then((clima) => console.log("Hoy: " + clima))
.catch((error) => console.log("No se pudo: " + error.message))
.finally(() => console.log("Consulta terminada"));
Crear una promesa
Para convertir algo basado en callbacks en una promesa, usas new Promise. Recibe una función con dos parámetros, resolve y reject, que llamas para cumplirla o rechazarla:
function esperar(ms) {
return new Promise((resolve) => {
setTimeout(() => resolve(ms), ms);
});
}
esperar(50).then((ms) => console.log("Pasaron " + ms + " ms"));
Con rechazo:
function obtenerClima(ciudad) {
return new Promise((resolve, reject) => {
setTimeout(() => {
if (ciudad === "Lima") {
resolve("nublado, 19 °C");
} else {
reject(new Error("Ciudad desconocida: " + ciudad));
}
}, 20);
});
}
Encadenar sin anidar
Aquí está la gran ventaja. Si dentro de un then devuelves un valor, el siguiente then lo recibe. Si devuelves una promesa, el siguiente then espera a que se cumpla. El callback hell de la lección anterior queda plano:
obtenerUsuario(1)
.then((usuario) => obtenerPedidos(usuario))
.then((pedidos) => obtenerDetalle(pedidos[0]))
.then((detalle) => calcularEnvio(detalle))
.then((envio) => console.log(envio))
.catch((error) => console.log("Algo falló: " + error.message));
Un solo catch al final captura el error de cualquier paso: si uno falla, se saltan los then siguientes y se va directo al catch.
Varias promesas a la vez
Promise.all
Si tienes varias tareas independientes, no tiene sentido esperarlas una tras otra. Promise.all recibe un array de promesas y devuelve una promesa que se cumple cuando todas terminan, con un array de resultados en el mismo orden:
Promise.all([esperar(30), esperar(10), esperar(20)])
.then((resultados) => console.log(resultados.join(", "))); // 30, 10, 20
Las tres esperas corren a la vez, así que el total tarda unos 30 ms y no 60. Si alguna se rechaza, Promise.all se rechaza de inmediato con ese error.
Otras combinaciones
| Método | Se cumple cuando... |
|---|---|
Promise.all |
Todas se cumplen (falla si una falla). |
Promise.allSettled |
Todas terminan, bien o mal; devuelve el estado de cada una. |
Promise.race |
La primera termina, bien o mal. |
Promise.any |
La primera se cumple. |
Promesas ya resueltas
Promise.resolve(valor) y Promise.reject(error) crean promesas que ya están cumplidas o rechazadas. Son útiles para pruebas o para devolver siempre una promesa desde una función:
Promise.resolve(42).then((n) => console.log(n)); // 42
Incluso así, el then se ejecuta después del código síncrono: los callbacks de las promesas también esperan su turno en el bucle de eventos.