Tres estados
Una promesa siempre está en uno de tres estados:
- Pendiente (pending): todavía no hay resultado.
- Cumplida (fulfilled): terminó bien y tiene un valor.
- Rechazada (rejected): falló y tiene un motivo, normalmente un
Error.
Pasa de pendiente a cumplida o rechazada una sola vez, y después ya no cambia. A una promesa que ya no está pendiente se le dice resuelta (settled).
const lista = Promise.resolve("lista");
const pendiente = new Promise(() => {}); // nunca se resuelve
const fallida = Promise.reject(new Error("ups"));
fallida.catch(() => {}); // la manejamos, para que no sea un rechazo sin catch
console.log(lista);
console.log(pendiente);
console.log(fallida);
Crear una promesa
new Promise recibe una función, que se ejecuta en el momento, con dos parámetros: uno para cumplir la promesa y otro para rechazarla.
function tirarDado() {
return new Promise((cumplir, rechazar) => {
setTimeout(() => {
const n = Math.ceil(Math.random() * 6);
if (n === 1) rechazar(new Error("salió 1: pierdes"));
else cumplir(n);
}, 100);
});
}
tirarDado()
.then((n) => console.log("salió", n))
.catch((e) => console.log(e.message));
Para envolver un valor que ya tienes: Promise.resolve(valor) y Promise.reject(error).
then, catch y finally
then(fn)registra qué hacer con el valor cuando la promesa se cumpla.catch(fn)registra qué hacer si se rechaza.finally(fn)se ejecuta en los dos casos, para limpiar.
const cargando = { visible: true };
Promise.resolve({ nombre: "Ana" })
.then((usuario) => console.log("hola,", usuario.nombre))
.catch((e) => console.log("no se pudo:", e.message))
.finally(() => {
cargando.visible = false;
console.log("ocultar el «cargando…»");
});
Encadenar
La clave de las promesas: then devuelve una promesa nueva, que se cumple con lo que devuelva su función. Por eso cada paso recibe el resultado del anterior, como muestra el pizarrón:
Promise.resolve(3)
.then((n) => n * 2) // 6
.then((n) => n + 1) // 7
.then((n) => console.log(n));
Si la función de un then devuelve otra promesa, la cadena espera a que se cumpla. Así, el callback hell del tema anterior queda plano:
const esperar = (ms, valor) => new Promise((r) => setTimeout(() => r(valor), ms));
const buscarUsuario = (id) => esperar(30, { id, nombre: "Ana" });
const buscarPedidos = (usuario) => esperar(30, ["té", "pan"]);
const calcularEnvio = (pedidos) => esperar(30, pedidos.length * 5);
buscarUsuario(7)
.then((usuario) => buscarPedidos(usuario))
.then((pedidos) => calcularEnvio(pedidos))
.then((envio) => console.log("envío:", envio))
.catch((e) => console.log("algo falló:", e.message));
Un solo catch al final atrapa el error de cualquier paso.
Errores que bajan por la cadena
Un rechazo, o un error lanzado dentro de un then, se salta todos los then hasta el primer catch. Y si el catch devuelve un valor, la cadena se recupera y sigue:
Promise.resolve("datos")
.then(() => {
throw new Error("falló el paso 2");
})
.then(() => console.log("no se ejecuta"))
.catch((e) => {
console.log("atrapado:", e.message);
return "valor por defecto";
})
.then((v) => console.log("sigue con:", v));
Resumen
- Una promesa está pendiente, cumplida (con un valor) o rechazada (con un motivo), y cambia una sola vez.
new Promise((cumplir, rechazar) => …)la crea; su función corre en el momento.thenmaneja el valor,catchel error yfinallycorre siempre.thendevuelve una promesa nueva: por eso se encadenan. Si devuelves una promesa, la cadena la espera.- Los errores bajan hasta el primer
catch.
¡A practicar!
Tu progreso se guarda en este navegador.
Autoevaluación: Un valor que llegará
Resuelto
Elige una respuesta en cada pregunta.
¿Cuáles son los estados de una promesa?
¿Qué devuelve
promesa.then(fn)?En una cadena, si un
thenlanza un error, ¿qué pasa con los siguientesthen?¿Cuándo se ejecuta el callback de
finally?
Ordena la salida: Una cadena con un tropiezo
Resuelto
Una cadena con un error en el medio. Ordena lo que aparecería en la consola.
1Promise.resolve(2)2 .then((n) => n * 10)3 .then((n) => {4 console.log("valor:", n);5 throw new Error("se rompió");6 })7 .then(() => console.log("esto no se ve"))8 .catch((e) => {9 console.log("catch:", e.message);10 return "recuperado";11 })12 .then((v) => console.log("después:", v))13 .finally(() => console.log("fin"));Consola, de arriba abajo
- después: recuperado
- valor: 20
- fin
- catch: se rompió
El error salta el then siguiente y cae en el catch. Como el catch devuelve un valor, la cadena se recupera: el siguiente then recibe "recuperado". finally corre al final.
Detective: Un then que no devuelve
Resuelto
Los pedidos se buscan, pero no llegan al último paso. Encuentra la línea y elige el arreglo.
Consola
pedidos.js:8
.then((pedidos) => console.log(pedidos.length));
^
TypeError: Cannot read properties of undefined (reading 'length')Paso 1: toca la línea de código que causa el error.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Esperar con una promesa
Resuelto
Escribe esperar(ms): una promesa que se cumple pasado un tiempo.
$ node programa.js
Lo que debe cumplir
- Imprime
esperando…y despuéspasaron 50 ms(pendiente) - Devuelve una promesa que tarda lo pedido (pendiente)
- Usa
new PromiseysetTimeout(pendiente)
Una solución
1function esperar(ms) {2 return new Promise((resolver) => setTimeout(resolver, ms));3}4 5esperar(50).then(() => console.log("pasaron 50 ms"));6console.log("esperando…");Es la forma de convertir cualquier API con callbacks en una promesa: creas la promesa y llamas a resolver (o a rechazar) desde el callback. Esta esperar te va a acompañar en todos los temas que siguen.