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...ofyawait; en paralelo conPromise.all. Nuncaawaitdentro deforEach. - 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
Resuelto
Elige una respuesta en cada pregunta.
¿Qué hace un debounce?
¿Y un throttle?
¿Por qué no funciona
lista.forEach(async (x) => await guardar(x))para esperar a que todo se guarde?Al reintentar una operación que falló, ¿por qué conviene esperar cada vez más entre intentos?
Ordena la salida: Un buscador con debounce
Resuelto
Un buscador que recibe cuatro llamadas. Ordena lo que aparecería en la consola.
1function debounce(fn, ms) {2 let id;3 return (...args) => {4 clearTimeout(id);5 id = setTimeout(() => fn(...args), ms);6 };7}8 9const buscar = debounce((texto) => console.log("busco:", texto), 50);10 11buscar("j");12buscar("ja");13buscar("jav");14setTimeout(() => buscar("javascript"), 100);15console.log("escribiendo…");Consola, de arriba abajo
- busco: javascript
- escribiendo…
- busco: jav
Las tres primeras llamadas llegan juntas: cada una cancela el temporizador de la anterior, así que solo sobrevive la última, "jav". La de los 100 ms llega después de la pausa y busca otra vez.
Detective: Un forEach que no espera
Resuelto
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.
Paso 2: ¿cómo lo arreglas?
Laboratorio: Reintentar con espera
Resuelto
Escribe reintentar(tarea, intentos) con una espera creciente entre intento e intento.
$ node programa.js
Lo que debe cumplir
- Imprime
¡conectado!yintentos: 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)
Una solución
1const esperar = (ms) => new Promise((r) => setTimeout(r, ms));2 3async function reintentar(tarea, intentos) {4 let ultimo;5 for (let i = 1; i <= intentos; i++) {6 try {7 return await tarea();8 } catch (e) {9 ultimo = e;10 if (i < intentos) await esperar(10 * 2 ** (i - 1));11 }12 }13 throw ultimo;14}15 16let veces = 0;17const inestable = async () => {18 veces++;19 if (veces < 3) throw new Error(`falló el intento ${veces}`);20 return "¡conectado!";21};22 23console.log(await reintentar(inestable, 5));24console.log("intentos:", veces);return await dentro del try es importante: sin el await, el rechazo de la tarea se escaparía del catch. Y la espera creciente (10, 20, 40…) es el backoff exponencial: le da al servicio tiempo de recuperarse.