0Pricing
Node.js Backend Development Bootcamp · Lektion

Asynchrone Iteratoren und for-await-of über Streams

Verarbeiten Sie Readable-Streams komfortabel per asynchroner Iteration und konvertieren Sie zwischen Streams und asynchronen Generatoren.

Asynchrone Iteratoren und for-await-of über Streams ist eine kostenlose Node.js Backend Development Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Node.js Backend Development Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Node.js Backend Development Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

Why Async Iteration Over Streams

Node.js Readable streams emit chunks over time. The classic way to consume them is by wiring up 'data', 'end', and 'error' event listeners. That works, but it scatters your logic across callbacks and makes pausing, resuming, and error handling awkward.

Since Node 10, every Readable stream is an async iterable. That means you can consume it with a plain for await...of loop:

  • Sequential chunk processing, written top to bottom
  • Automatic backpressure — the loop pulls one chunk at a time
  • try/catch works for stream errors

This lesson shows how to consume, transform, and produce streams ergonomically with async iteration.

for-await-of Basics

A for await...of loop awaits each value produced by an async iterator before moving to the next. When applied to a Readable stream, each iteration yields one chunk (a Buffer by default, or a string if the stream encoding is set).

Here we read this script's own source file line-by-chunk. The loop body runs once per chunk and the loop naturally ends when the stream finishes:

import { createReadStream } from 'node:fs';
import { fileURLToPath } from 'node:url';

const self = fileURLToPath(import.meta.url);
const stream = createReadStream(self, { encoding: 'utf8' });

let chunks = 0;
let bytes = 0;
for await (const chunk of stream) {
  chunks++;
  bytes += chunk.length;
}
console.log('chunks:', chunks, 'chars:', bytes);

Built-in Backpressure

The biggest win of for await...of is automatic backpressure. The loop requests the next chunk only when the previous iteration's body has finished awaiting. If your body does slow async work (a DB write, an HTTP call), the stream is paused until you are ready.

You get this for free — no manual stream.pause() / stream.resume() dance. This simulated example processes each chunk with a delay; the stream waits between iterations:

import { Readable } from 'node:stream';
import { setTimeout as sleep } from 'node:timers/promises';

const source = Readable.from(['a', 'b', 'c', 'd']);

for await (const item of source) {
  // Slow consumer: stream is paused while we await
  await sleep(50);
  console.log('processed', item);
}
console.log('done');

Readable.from(): Iterable to Stream

Readable.from() turns any iterable or async iterable (arrays, generators, async generators) into a proper Readable stream. This is the bridge from plain data or generator logic into the stream ecosystem (pipes, HTTP responses, file writes).

You can hand it a generator function result to lazily produce values:

import { Readable } from 'node:stream';

function* counter(n) {
  for (let i = 1; i <= n; i++) {
    yield `line ${i}\n`;
  }
}

const stream = Readable.from(counter(3));

for await (const chunk of stream) {
  process.stdout.write(chunk);
}

Async Generators as Stream Sources

Readable.from() also accepts an async generator. This lets you produce stream data from asynchronous sources — paginated APIs, queued jobs, or timed events — while keeping clean sequential code.

The async generator below yields a record every short interval, and Readable.from() exposes it as a standard stream any Node consumer can read:

import { Readable } from 'node:stream';
import { setTimeout as sleep } from 'node:timers/promises';

async function* fetchPages() {
  for (let page = 1; page <= 3; page++) {
    await sleep(20); // simulate async fetch
    yield { page, items: page * 2 };
  }
}

const stream = Readable.from(fetchPages(), { objectMode: true });

for await (const record of stream) {
  console.log('got page', record.page, 'items', record.items);
}

Object Mode Streams

By default streams carry Buffer or string chunks. When you set objectMode: true, each chunk is an arbitrary JavaScript value — an object, a number, an array. This is essential when async-iterating over structured records rather than raw bytes.

Readable.from() auto-enables object mode when the source yields non-string/Buffer values, but being explicit keeps intent clear. Async iteration then yields your objects directly:

import { Readable } from 'node:stream';

const users = [
  { id: 1, name: 'Ada' },
  { id: 2, name: 'Linus' },
  { id: 3, name: 'Grace' },
];

const stream = Readable.from(users, { objectMode: true });

for await (const user of stream) {
  console.log(`#${user.id} -> ${user.name}`);
}

Transforming via Async Generators

You do not always need a Transform stream class to map or filter stream data. You can wrap the source stream in an async generator that itself uses for await...of, yielding transformed values. This composes naturally and reads like synchronous code.

Here a generator parses NDJSON-style lines into objects and filters them, all while preserving backpressure:

import { Readable } from 'node:stream';

async function* onlyActive(source) {
  for await (const record of source) {
    if (record.active) {
      yield record.name;
    }
  }
}

const input = Readable.from([
  { name: 'job-a', active: true },
  { name: 'job-b', active: false },
  { name: 'job-c', active: true },
], { objectMode: true });

for await (const name of onlyActive(input)) {
  console.log('active:', name);
}

Error Handling with try/catch

A major ergonomic gain: stream errors surface as thrown exceptions inside the loop, so a normal try/catch handles them. With event-based consumption you had to listen for 'error' separately and risk unhandled rejections.

If the stream emits 'error' mid-iteration, the awaited next() rejects and control jumps to catch:

import { Readable } from 'node:stream';

async function* faulty() {
  yield 1;
  yield 2;
  throw new Error('source blew up');
}

const stream = Readable.from(faulty(), { objectMode: true });

try {
  for await (const n of stream) {
    console.log('value', n);
  }
} catch (err) {
  console.error('caught:', err.message);
}

Early break Destroys the Stream

When you break, return, or throw out of a for await...of loop, Node calls the iterator's return() method, which destroys the underlying stream and releases its resources (file descriptors, sockets). This is a crucial cleanup guarantee.

So stopping after the first match does not leak the open file handle — the stream is torn down automatically:

import { Readable } from 'node:stream';

const stream = Readable.from(['alpha', 'beta', 'gamma', 'delta']);

for await (const word of stream) {
  console.log('checking', word);
  if (word === 'beta') {
    console.log('found it, stopping');
    break; // stream is destroyed on break
  }
}
console.log('destroyed?', stream.destroyed);

Consuming an HTTP Request Body

In a Node backend, an incoming HTTP request (req) is a Readable stream. Async iteration is a clean way to collect or process the request body without buffering everything manually.

This pattern accumulates chunks then parses JSON. Because it is server code (it binds a port and needs an HTTP client), it is illustrative rather than self-running here:

import { createServer } from 'node:http';

const server = createServer(async (req, res) => {
  try {
    const chunks = [];
    for await (const chunk of req) {
      chunks.push(chunk);
    }
    const body = Buffer.concat(chunks).toString('utf8');
    const data = JSON.parse(body || '{}');
    res.end(JSON.stringify({ received: data }));
  } catch (err) {
    res.statusCode = 400;
    res.end('bad request');
  }
});

server.listen(3000);

Iterator Helpers and stream.compose()

Modern Node adds higher-order helpers directly on Readable streams that consume the async iterator under the hood: stream.map(), stream.filter(), stream.toArray(), stream.take(), and more. They keep backpressure while letting you avoid hand-written loops.

You can chain them fluently. toArray() drains the stream and resolves to a plain array:

  • .map(fn) — transform each chunk (supports async fn + concurrency)
  • .filter(fn) — keep matching chunks
  • .toArray() — collect everything into an array
import { Readable } from 'node:stream';

const result = await Readable.from([1, 2, 3, 4, 5])
  .filter((n) => n % 2 === 1)
  .map((n) => n * 10)
  .toArray();

console.log(result); // [10, 30, 50]

Quick Check

You consume a Readable file stream with for await...of and break out of the loop after finding the first matching line. What happens to the underlying file resource?

Recap

You learned to consume and produce Node streams with async iteration:

  • for await...of reads a Readable one chunk at a time with built-in backpressure and try/catch error handling.
  • Readable.from() converts arrays, generators, and async generators into streams; use objectMode for structured records.
  • Wrap a source in an async generator to map/filter while preserving backpressure — no Transform class needed.
  • break/return/throw destroys the stream and frees resources automatically.
  • Helpers like .map(), .filter(), and .toArray() offer a fluent alternative to manual loops.

Reach for async iteration whenever you want sequential, readable, leak-safe stream consumption in your backend.

Häufig gestellte Fragen

Ist die Lektion „Asynchrone Iteratoren und for-await-of über Streams“ kostenlos?

Ja — der vollständige Text von „Asynchrone Iteratoren und for-await-of über Streams“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Node.js Backend Development Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Node.js Backend Development Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Asynchrone Iteratoren und for-await-of über Streams“?

Verarbeiten Sie Readable-Streams komfortabel per asynchroner Iteration und konvertieren Sie zwischen Streams und asynchronen Generatoren. Du übst Node.js Backend Development Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Node.js Backend Development Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. Node.js Backend Development Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „Asynchrone Iteratoren und for-await-of über Streams“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Node.js Backend Development Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede Node.js Backend Development Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Interna von Readable-, Writable-, Duplex- und Transform-Streams
  2. Eigene Transform-Streams mit _transform und _flush implementieren
  3. Backpressure, pipe() und das pipeline()-Hilfsprogramm
  4. Asynchrone Iteratoren und for-await-of über Streams
← Zurück zu Node.js Backend Development Bootcamp