Saltar al contenido
Asincronía

Patrones asíncronos

Lección 9 de 912 min4 ejercicios

Con promesas, async/await, combinadores y cancelación ya tienes todas las piezas. Este tema las combina en recetas que vas a necesitar una y otra vez: no saturar un servidor, reintentar lo que falla, esperar a que el usuario termine de escribir.

En serie, en paralelo y en un forEach

const esperar = (ms, valor) => new Promise((r) => setTimeout(() => r(valor), ms));
const ids = [1, 2, 3];

// En serie: una tras otra (cuando cada paso necesita el anterior)
const enSerie = [];
for (const id of ids) {
  enSerie.push(await esperar(20, id));
}

// En paralelo: todas a la vez
const enParalelo = await Promise.all(ids.map((id) => esperar(20, id)));

console.log(enSerie, enParalelo);

Concurrencia limitada

Promise.all lanza todo a la vez. Con mil pedidos, eso puede saturar un servidor o el navegador. La solución: un número fijo de “trabajadores” que toman tareas de una fila común.

const esperar = (ms, valor) => new Promise((r) => setTimeout(() => r(valor), ms));

async function conLimite(tareas, maximo) {
  const resultados = [];
  let siguiente = 0;
  let enCurso = 0;
  let pico = 0;

  async function trabajador() {
    while (siguiente < tareas.length) {
      const i = siguiente++;
      enCurso++;
      pico = Math.max(pico, enCurso);
      resultados[i] = await tareas[i]();
      enCurso--;
    }
  }

  await Promise.all(Array.from({ length: maximo }, trabajador));
  console.log("como máximo a la vez:", pico);
  return resultados;
}

const tareas = [1, 2, 3, 4, 5, 6].map((n) => () => esperar(20, n * 10));
console.log(await conLimite(tareas, 2));

Las tareas son funciones que devuelven promesas, no promesas: así no empiezan hasta que un trabajador las toma.

Reintentos con backoff

Las operaciones de red fallan a veces por motivos pasajeros. Reintentar ayuda, pero sin martillar: entre intento e intento, se espera cada vez más (100 ms, 200, 400…). Lo vas a escribir en el laboratorio.

Límite de tiempo

Ya lo viste con Promise.race y con AbortSignal.timeout. La segunda opción es mejor cuando la operación acepta una señal, como fetch, porque además la cancela:

// Con race: deja de esperar, pero la operación sigue
// Con una señal: deja de esperar y la operación se detiene
fetch(url, { signal: AbortSignal.timeout(5000) });

Debounce

Un debounce retrasa la ejecución hasta que pasa un tiempo sin nuevas llamadas. Ideal para buscar mientras el usuario escribe:

function debounce(fn, ms) {
  let id;
  return (...args) => {
    clearTimeout(id);                         // cada llamada cancela la anterior…
    id = setTimeout(() => fn(...args), ms);   // …y programa una nueva
  };
}

const guardar = debounce((texto) => console.log("guardado:", texto), 50);
guardar("h");
guardar("ho");
guardar("hola");  // solo esta se guarda

Throttle

Un throttle deja pasar como máximo una ejecución cada cierto tiempo, aunque lo llamen sin parar. Ideal para el scroll o el redimensionado de la ventana:

function throttle(fn, ms) {
  let ultimo = 0;
  return (...args) => {
    const ahora = performance.now();
    if (ahora - ultimo >= ms) {
      ultimo = ahora;
      fn(...args);
    }
  };
}

const registrar = throttle((n) => console.log("posición", n), 30);
let n = 0;
const id = setInterval(() => {
  registrar(++n);           // se llama cada 5 ms…
  if (n === 20) clearInterval(id);
}, 5);                      // …pero registra como mucho cada 30 ms

Resumen

  • En serie con for...of y await; en paralelo con Promise.all. Nunca await dentro de forEach.
  • Concurrencia limitada: unos pocos trabajadores toman tareas de una fila común.
  • Reintentos con espera creciente (backoff exponencial).
  • Límites de tiempo: mejor con AbortSignal.timeout, que además cancela.
  • Debounce: una ejecución cuando las llamadas se detienen. Throttle: como máximo una cada cierto tiempo.

¡A practicar!

Tu progreso se guarda en este navegador.

Autoevaluación: Recetas para esperar bien

Elige una respuesta en cada pregunta.

  1. ¿Qué hace un debounce?

  2. ¿Y un throttle?

  3. ¿Por qué no funciona lista.forEach(async (x) => await guardar(x)) para esperar a que todo se guarde?

  4. Al reintentar una operación que falló, ¿por qué conviene esperar cada vez más entre intentos?

Ordena la salida: Un buscador con debounce

Un buscador que recibe cuatro llamadas. Ordena lo que aparecería en la consola.

function debounce(fn, ms) {  let id;  return (...args) => {    clearTimeout(id);    id = setTimeout(() => fn(...args), ms);  };} const buscar = debounce((texto) => console.log("busco:", texto), 50); buscar("j");buscar("ja");buscar("jav");setTimeout(() => buscar("javascript"), 100);console.log("escribiendo…");

Consola, de arriba abajo

  1. busco: javascript
  2. escribiendo…
  3. busco: jav

Detective: Un forEach que no espera

Se cargan tres elementos, pero al usarlos no hay ninguno. Encuentra la línea y elige el arreglo.

Consola

items.js:8
console.log(resultados[0].nombre);
                          ^

TypeError: Cannot read properties of undefined (reading 'nombre')

Paso 1: toca la línea de código que causa el error.

Laboratorio: Reintentar con espera

Escribe reintentar(tarea, intentos) con una espera creciente entre intento e intento.

programa.jsse ejecuta mientras escribes

$ node programa.js

(escribe tu código: se ejecuta solo)

Lo que debe cumplir

  • Imprime ¡conectado! y intentos: 3 (pendiente)
  • Si nunca funciona, rechaza con el último error tras los intentos pedidos (pendiente)
  • Espera entre intentos: tres intentos fallidos esperan 10 + 20 ms (pendiente)

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