Saltar al contenido
Asincronía

Promesas

Lección 4 de 913 min4 ejercicios

Una promesa es un objeto que representa un valor que todavía no existe: la respuesta de un servidor, el contenido de un archivo, el resultado de un cálculo lento. En lugar de pasar un callback y confiar, recibes un objeto que puedes guardar, pasar, encadenar y combinar. Es la base de todo el JavaScript asíncrono moderno.

Qué mirar en el pizarrón

Los recuadros punteados son promesas. Fíjate en cómo cambia el estado de cada una, en qué momento se ejecuta cada función de los then y en qué cola espera antes de entrar a la pila.

En el pizarrón

const pedido = new Promise((resolver) => {  setTimeout(() => resolver("pizza"), 100);}); console.log("pedido hecho"); pedido  .then((comida) => comida.toUpperCase())  .then((texto) => console.log(`llegó: ${texto}`));

Pila, APIs y colas

  1. promesa #1pendiente
  2. temporizador de 100 msresolverá la promesa
Consola(vacía)

new Promise ejecuta su función en el momento, que deja un temporizador. La promesa nace pendiente: todavía no tiene valor.

Con el foco aquí también puedes avanzar y retroceder con las flechas del teclado.

Ver todos los pasos en texto
  1. Paso 1: new Promise ejecuta su función en el momento, que deja un temporizador. La promesa nace pendiente: todavía no tiene valor. Estado: promesa #1 pendiente, Web API: temporizador de 100 ms resolverá la promesa.
  2. Paso 2: El programa no se detiene a esperar: sigue con la línea 5. Estado: promesa #1 pendiente, Web API: temporizador de 100 ms resolverá la promesa.
  3. Paso 3: Cada then registra una función para cuando la promesa se cumpla, y devuelve una promesa nueva. Las funciones todavía no se ejecutaron. Estado: promesa #1 pendiente · avisará a #2, promesa #2 pendiente · avisará a #3, promesa #3 pendiente, Web API: temporizador de 100 ms.
  4. Paso 4: A los 100 ms, el callback del temporizador llama a resolver("pizza"): la promesa #1 pasa a cumplida, para siempre. Su reacción, la función del primer then, entra a la cola de microtareas. Estado: pila: callback del temporizador resolver("pizza"), promesa #1 cumplida: "pizza", promesa #2 pendiente, promesa #3 pendiente, microtareas: (comida) => comida.toUpperCase() lista para correr.
  5. Paso 5: La función recibe "pizza" y devuelve "PIZZA". Con ese valor se cumple la promesa #2, y su reacción entra a las microtareas. Estado: pila: (comida) => … devuelve "PIZZA", promesa #1 cumplida: "pizza", promesa #2 cumplida: "PIZZA", promesa #3 pendiente, microtareas: (texto) => console.log(…) lista para correr.
  6. Paso 6: El último then recibe "PIZZA" y lo imprime. No devuelve nada, así que la promesa #3 se cumple con undefined. Estado: pila: (texto) => console.log(…) true, promesa #1 cumplida: "pizza", promesa #2 cumplida: "PIZZA", promesa #3 cumplida: undefined.
  7. Paso 7: Una promesa es un recipiente para un valor futuro. then no espera: encadena funciones que el event loop ejecutará, como microtareas, cuando el valor llegue. Estado: promesa #1 cumplida: "pizza", promesa #2 cumplida: "PIZZA", promesa #3 cumplida: undefined.

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.
  • then maneja el valor, catch el error y finally corre siempre.
  • then devuelve 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á

Elige una respuesta en cada pregunta.

  1. ¿Cuáles son los estados de una promesa?

  2. ¿Qué devuelve promesa.then(fn)?

  3. En una cadena, si un then lanza un error, ¿qué pasa con los siguientes then?

  4. ¿Cuándo se ejecuta el callback de finally?

Ordena la salida: Una cadena con un tropiezo

Una cadena con un error en el medio. Ordena lo que aparecería en la consola.

Promise.resolve(2)  .then((n) => n * 10)  .then((n) => {    console.log("valor:", n);    throw new Error("se rompió");  })  .then(() => console.log("esto no se ve"))  .catch((e) => {    console.log("catch:", e.message);    return "recuperado";  })  .then((v) => console.log("después:", v))  .finally(() => console.log("fin"));

Consola, de arriba abajo

  1. después: recuperado
  2. valor: 20
  3. fin
  4. catch: se rompió

Detective: Un then que no devuelve

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.

Laboratorio: Esperar con una promesa

Escribe esperar(ms): una promesa que se cumple pasado un tiempo.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime esperando… y después pasaron 50 ms (pendiente)
  • Devuelve una promesa que tarda lo pedido (pendiente)
  • Usa new Promise y setTimeout (pendiente)

    domina-js · JavaScript en español, gratis y paso a paso.