Stream types (Readable, Writable, Transform, Duplex) in Node.js - Step-by-Step Execution

Concept Flow - Stream types (Readable, Writable, Transform, Duplex)

Start Stream Operation

↓

Readable

↓

Data Out

↓

Stream Ends or Pipes to Next

This flow shows how a stream operation starts by choosing one of four stream types, each handling data flow differently.

Execution Sample

Node.js

import { Readable, Writable, Transform, Duplex } from 'stream';

const readable = new Readable({
  read() { this.push('Hello'); this.push(null); }
});

const writable = new Writable({
  write(chunk, _, cb) { console.log(chunk.toString()); cb(); }
});

readable.pipe(writable);

This code creates a readable stream that outputs 'Hello' and a writable stream that logs data, then pipes readable to writable.

Execution Table

Step	Action	Stream Type	Data Chunk	Output/Effect
1	Create Readable stream	Readable		Stream ready to emit data
2	Create Writable stream	Writable		Stream ready to receive data
3	readable.pipe(writable)	Readable -> Writable		Connects streams, triggers readable.read()
4	Readable read() called	Readable	'Hello'	Pushes 'Hello' to internal buffer, pipe sends to writable
5	Readable pushes null	Readable	null	Signals end of data
6	Writable write() called	Writable	'Hello'	Logs 'Hello' to console
7	Writable write() callback	Writable		Signals write complete
8	Stream ends	Readable & Writable		No more data, streams close

💡 Streams end after readable pushes null and writable finishes writing

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	After Step 6	Final
readable internal buffer	empty	empty	'Hello'	null (end)	empty (piped out)	closed
writable received data	empty	empty	'Hello'	'Hello'	'Hello'	closed

Key Moments - 3 Insights

Why does the readable stream push null after 'Hello'?

Pushing null signals the end of data, so writable knows no more data is coming (see Step 5 in execution_table).

What happens when readable.pipe(writable) is called?

It connects readable output to writable input, so data flows automatically from readable to writable (see Step 3).

Why does writable call a callback after writing?

The callback signals that the write is complete and the stream can accept more data or end (see Step 7).

Visual Quiz - 3 Questions

Look at the execution table, what data chunk does the readable stream push first?

A 'Hello'

B null

C 'World'

D empty string

💡 Hint

Check Step 4 in the execution_table where readable pushes data

At which step does the writable stream receive data from readable?

A Step 3

B Step 5

C Step 4

D Step 7

💡 Hint

Look for the Readable read() call where data is piped to writable in execution_table

If readable did not push null, what would happen?

A Readable would throw an error

B Writable would never know the stream ended

C Writable would close immediately

D Data would be lost

💡 Hint

Refer to Step 5 where pushing null signals end of data

Concept Snapshot

Node.js streams handle data flow in four types:
- Readable: outputs data
- Writable: accepts data
- Transform: modifies data as it passes
- Duplex: both readable and writable
Use pipe() to connect streams for smooth data transfer.
Push null in readable to signal end.

Full Transcript

Node.js streams come in four types: Readable streams produce data, Writable streams consume data, Transform streams modify data while passing it through, and Duplex streams can do both reading and writing. In the example, a Readable stream pushes the string 'Hello' and then pushes null to signal no more data. A Writable stream receives this data and logs it. The pipe() method connects the readable to the writable, so data flows automatically. The writable calls a callback after writing to signal completion. Pushing null is important to tell the writable stream that the data has ended, so it can close properly.

Practice

1. Which type of Node.js stream is designed to only provide data piece by piece for reading?

easy

A. Transform stream

B. Readable stream

C. Writable stream

D. Duplex stream

Solution

1. Step 1: Understand stream roles

   Readable streams are designed to emit data chunks for consumption.

2. Step 2: Match stream type to description

   Only readable streams provide data piece by piece without accepting input.

3. Final Answer:

   Readable stream -> Option B

4. Quick Check:

   Readable = provides data [OK]

Hint: Readable streams only output data, no input accepted [OK]

Common Mistakes:

• Confusing writable streams as data providers
• Thinking transform streams only read data
• Mixing duplex with readable-only behavior

2. Which of the following is the correct way to create a writable stream in Node.js?

easy

A. const stream = new Readable();

B. const stream = new Duplex();

C. const stream = new Transform();

D. const stream = new Writable({ write(chunk, encoding, callback) { callback(); } });

Solution

1. Step 1: Identify writable stream creation

   Writable streams require a write method to handle incoming data chunks.

2. Step 2: Check options for correct syntax

   const stream = new Writable({ write(chunk, encoding, callback) { callback(); } }); correctly creates a Writable stream with a write method and callback.

3. Final Answer:

   const stream = new Writable({ write(chunk, encoding, callback) { callback(); } }); -> Option D

4. Quick Check:

   Writable needs write() method [OK]

Hint: Writable streams need a write() method in options [OK]

Common Mistakes:

• Using Readable constructor for writable stream
• Omitting write method in Writable options
• Confusing Transform or Duplex constructors

3. What will be the output of the following code snippet?

const { Transform } = require('stream');
const upperCase = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

upperCase.on('data', data => console.log(data.toString()));
upperCase.write('hello');
upperCase.end();

medium

A. HELLO

B. hello

C. undefined

D. Error: callback not called

Solution

1. Step 1: Understand Transform stream behavior

   The transform method converts input chunk to uppercase and pushes it forward.

2. Step 2: Analyze event and output

   The 'data' event logs the transformed chunk, which is uppercase 'HELLO'.

3. Final Answer:

   HELLO -> Option A

4. Quick Check:

   Transform changes data to uppercase [OK]

Hint: Transform streams modify data before output [OK]

Common Mistakes:

• Expecting original lowercase output
• Forgetting to call callback() in transform
• Assuming no output without explicit read

4. Identify the error in this Duplex stream implementation:

const { Duplex } = require('stream');
const duplex = new Duplex({
  read(size) {
    this.push('data');
  },
  write(chunk, encoding, callback) {
    console.log(chunk.toString());
    callback();
  }
});
duplex.on('data', data => console.log('Received:', data.toString()));
duplex.write('hello');

medium

A. The Duplex constructor is missing the object mode option

B. The write method is missing the callback call

C. The read method should push null to signal end of data

D. The duplex stream cannot both read and write

Solution

1. Step 1: Check read method behavior

   The read method pushes 'data' but never signals end by pushing null.

2. Step 2: Understand stream end signaling

   Streams must push null to indicate no more data; missing here causes hanging.

3. Final Answer:

   The read method should push null to signal end of data -> Option C

4. Quick Check:

   read() must push null to end stream [OK]

Hint: read() must push null to end data stream [OK]

Common Mistakes:

• Not pushing null in read method
• Forgetting callback in write method
• Assuming Duplex can't read and write

5. You want to create a custom Duplex stream that reads numbers from 1 to 3 and writes their squares. Which approach correctly implements this behavior?

hard

A. Push numbers 1 to 3 in read(), write() logs squares, and push null after 3

B. Push squares in read(), write() pushes numbers 1 to 3, no null needed

C. Use Transform stream instead of Duplex for this task

D. Only Writable stream can handle both reading and writing

Solution

1. Step 1: Understand Duplex stream roles

   Duplex streams can read and write independently; read() pushes data, write() processes input.

2. Step 2: Match behavior to implementation

   Push numbers 1 to 3 in read(), write() logs squares, and push null after last number to end stream.

3. Final Answer:

   Push numbers 1 to 3 in read(), write() logs squares, and push null after 3 -> Option A

4. Quick Check:

   Duplex reads numbers, writes squares [OK]

Hint: Duplex streams read and write independently [OK]

Common Mistakes:

• Confusing Transform with Duplex for this task
• Not pushing null to end read stream
• Thinking Writable streams can read data