JavaScript
Explica los iterables asíncronos, el protocolo Symbol.asyncIterator y el uso de for await...of para consumir datos que llegan de forma progresiva.
Un iterable asíncrono entrega valores uno a uno, pero cada paso puede requerir esperar.
const iterator = source[Symbol.asyncIterator]();
const result = await iterator.next();Un iterador asíncrono implementa next y retorna una promesa de registro:
{
value,
done,
}const iterator = {
async next() {
return {
value: await readNextValue(),
done: false,
};
},
};Un iterable asíncrono implementa Symbol.asyncIterator.
async function* readPages(fetchPage) {
let page = 1;
while (true) {
const result = await fetchPage(page);
if (result.items.length === 0) {
return;
}
yield result.items;
page++;
}
}La función combina await para esperar y yield para producir.
for await (const items of readPages(fetchPage)) {
renderItems(items);
}Cada iteración espera el siguiente registro.
for await...of también puede consumir un iterable síncrono cuyos valores son promesas.
for await (const value of [
Promise.resolve(1),
Promise.resolve(2),
]) {
console.log(value);
}Aun así, un iterable asíncrono real controla cuándo produce cada paso.
const values = await Array.fromAsync(source);Construye un array consumiendo una fuente asíncrona o valores que necesitan resolución.
No lo uses con secuencias infinitas ni cuando materializar todo elimina la ventaja del procesamiento gradual.
for await (const item of source) {
await saveItem(item);
}Cada saveItem termina antes de solicitar la siguiente iteración.
Para concurrencia, debes diseñarla explícitamente y considerar backpressure.
Muchos streams del entorno pueden exponerse como iterables asíncronos o lectores que entregan chunks.
for await (const chunk of stream) {
processChunk(chunk);
}La disponibilidad concreta depende del runtime.
for await (const item of source) {
if (shouldStop(item)) {
break;
}
}El consumidor solicita cierre mediante return cuando el iterador lo implementa. Un async generator puede ejecutar finally.
async function* source() {
try {
while (true) {
yield await read();
}
} finally {
await close();
}
}Si next rechaza o el generator lanza, el bucle falla.
try {
for await (const item of source) {
process(item);
}
} catch (error) {
handle(error);
}async function* source({ signal }) {
while (true) {
signal.throwIfAborted();
yield await readNext({ signal });
}
}La señal debe llegar a las operaciones internas.
async function* listProducts(client, { signal }) {
let cursor;
do {
signal.throwIfAborted();
const page = await client.list({
cursor,
signal,
});
yield* page.items;
cursor = page.nextCursor;
} while (cursor);
}El consumidor puede detenerse sin cargar todas las páginas.
Symbol.asyncIterator crea iteradores cuyos pasos son asíncronos.for await...of espera cada registro.¿Qué ventaja tiene un async generator frente a retornar un array con todas las páginas?
Puede producir y consumir datos gradualmente, detenerse antes, reducir memoria y respetar mejor el ritmo del consumidor.
Patrones y errores frecuentes de asincronía reúne las decisiones que hacen un flujo asíncrono predecible.