Node.js v10: Stream API vs (async) Generators

Understanding Streams and Generators in Node.js

Node.js provides two powerful tools for handling asynchronous data: streams and generators. While they share some similarities, they have distinct approaches to managing data flow.

Streams: A Buffered Approach

Streams are a built-in Node.js API that allows you to handle asynchronous data in a buffered manner. A stream is an abstraction of data that can be read from or written to in chunks, rather than all at once. This makes it ideal for handling large datasets or continuous data flows.

Creating a Synchronous Counter with Streams

To demonstrate how streams work, let’s create a simple synchronous counter using the Readable stream class.
“`javascript
const { Readable } = require(‘stream’);

class CounterStream extends Readable {
constructor() {
super({ objectMode: true });
this.count = 0;
}

_read() {
this.push(this.count++);
}
}

const counter = new CounterStream();
counter.pipe(process.stdout);
“`
This code creates a readable stream that generates an infinite sequence of numbers, starting from 0.

Generators: A Pull-Based Approach

Generators, introduced in ES2015, provide an alternative way to handle asynchronous data. Unlike streams, generators use a pull-based approach, where the consumer controls the data flow.

Creating a Synchronous Counter with Generators

Let’s recreate the synchronous counter using a generator.
“`javascript
function* counter() {
let count = 0;
while (true) {
yield count++;
}
}

for (const num of counter()) {
console.log(num);
}
“
This code defines a generator function that produces an infinite sequence of numbers, starting from 0. Thefor…of` loop consumes the generator, logging each number to the console.

Asynchronous Counters

Now, let’s create asynchronous counters using both streams and generators.

Streams: A Push-Based Approach

For streams, we’ll use the setInterval function to simulate an asynchronous data source.
“`javascript
const { Readable } = require(‘stream’);

class AsyncCounterStream extends Readable {
constructor() {
super({ objectMode: true });
this.count = 0;
setInterval(() => this.push(this.count++), 1000);
}
}

const asyncCounter = new AsyncCounterStream();
asyncCounter.pipe(process.stdout);
“`
This code creates a readable stream that generates an infinite sequence of numbers, incrementing every second.

Generators: A Pull-Based Approach

For generators, we’ll use the for await...of syntax to handle promises.
“`javascript
async function* asyncCounter() {
let count = 0;
while (true) {
await new Promise(resolve => setTimeout(resolve, 1000));
yield count++;
}
}

for await (const num of asyncCounter()) {
console.log(num);
}
“
This code defines a generator function that produces an infinite sequence of numbers, incrementing every second. Thefor await…of` loop consumes the generator, logging each number to the console.

Comparison

While both streams and generators can handle asynchronous data, they differ in their approach. Streams use a buffered approach, whereas generators use a pull-based approach. Understanding these differences can help you choose the best tool for your specific use case.