0Pricing
Node.js Backend Development Bootcamp · Lesson

Async Iterators and for-await-of Over Streams

Consume Readable streams ergonomically with async iteration and convert between streams and async generators.

Async Iterators and for-await-of Over Streams is a free Node.js Backend Development Bootcamp lesson on CoddyKit — lesson 4 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Node.js Backend Development Bootcamp learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

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.

Frequently asked questions

Is the “Async Iterators and for-await-of Over Streams” lesson free?

Yes — the full text of “Async Iterators and for-await-of Over Streams” is free to read here on the web, and the Node.js Backend Development Bootcamp course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Node.js Backend Development Bootcamp course, upgrade to CoddyKit PRO.

What will I learn in “Async Iterators and for-await-of Over Streams”?

Consume Readable streams ergonomically with async iteration and convert between streams and async generators. You practise Node.js Backend Development Bootcamp with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Node.js Backend Development Bootcamp?

No prior experience is required. Node.js Backend Development Bootcamp on CoddyKit is structured for beginners through advanced learners; this is — lesson 4 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Async Iterators and for-await-of Over Streams” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Node.js Backend Development Bootcamp lesson?

Yes. Every Node.js Backend Development Bootcamp lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. Readable, Writable, Duplex & Transform Stream Internals
  2. Implementing Custom Transform Streams with _transform and _flush
  3. Backpressure, pipe() and the pipeline() Utility
  4. Async Iterators and for-await-of Over Streams
← Back to Node.js Backend Development Bootcamp