Saltar al contenido

Sección 5: Asincronía, 0 de 3 lecciones completadas

Lección 17 de 22Asincronía

Promesas

  • 7 min de lectura
  • 3 ejercicios

Aprende a usar promesas en JavaScript: crear una con new Promise, encadenar then y catch, usar finally y ejecutar tareas en paralelo con Promise.all.

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.

Puntos clave

  • Una promesa representa un valor que estará disponible en el futuro.
  • Una promesa está pendiente, cumplida (resolve) o rechazada (reject), y solo cambia de estado una vez.
  • then recibe el valor cuando se cumple; catch, el error cuando se rechaza.
  • Si un then devuelve un valor o una promesa, el siguiente then lo recibe: así se encadenan pasos sin anidar.
  • Promise.all espera varias promesas en paralelo y falla si alguna falla.

Hora de practicar

Ejercicios

0/3 resueltos

Reto 1 de 3

Ejercicio 1: Tu propia promesa

Completa esperar(ms, valor) para que devuelva una promesa que se cumpla con valor después de ms milisegundos, usando new Promise y setTimeout.

El código de abajo ya la usa. La salida debe ser:

Esperando...
listo
function esperar(ms, valor) {
  // TODO: devuelve una new Promise que llame a resolve(valor) tras ms milisegundos
}

esperar(20, "listo").then((v) => console.log(v));
console.log("Esperando...");

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Reto 2 de 3

Ejercicio 2: Encadena los pasos

Usa .then para encadenar los pasos, sin anidarlos:

  1. obtenerPrecio("libro") devuelve una promesa con el precio.
  2. Pasa ese precio a aplicarImpuesto(precio), que también devuelve una promesa.
  3. Muestra el resultado con el formato Total: 59.

Agrega un .catch al final que muestre "Error: " más el mensaje. La salida debe ser:

Total: 59
const obtenerPrecio = (producto) =>
  new Promise((resolve) => setTimeout(() => resolve(50), 10));
const aplicarImpuesto = (precio) =>
  new Promise((resolve) => setTimeout(() => resolve(precio * 1.18), 10));

// TODO: encadena obtenerPrecio, aplicarImpuesto y muestra "Total: ..."
// TODO: agrega un .catch al final

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

Reto 3 de 3

Ejercicio 3: Todos a la vez

Tienes tres consultas que tardan 30, 10 y 20 ms. Usa Promise.all para esperarlas en paralelo y muestra la suma de sus resultados. La salida debe ser:

Total de visitas: 60
const visitas = (cantidad, ms) =>
  new Promise((resolve) => setTimeout(() => resolve(cantidad), ms));

const consultas = [visitas(25, 30), visitas(15, 10), visitas(20, 20)];

// TODO: usa Promise.all con consultas y muestra la suma de los resultados

Pulsa «Ejecutar» (o Ctrl + Enter) para ver la salida.

¿Has encontrado un error en esta lección? Avísanos