Stream types (Readable, Writable, Transform, Duplex) in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this Readable stream output?

Consider this Node.js Readable stream code. What will be printed to the console?

Node.js

import { Readable } from 'stream';

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

readable.on('data', chunk => console.log(chunk.toString()));

A Hello\nWorld

B HelloWorld

C Hello\nWorld\n

D Hello\nHelloWorld

💡 Hint

Remember that 'data' event emits chunks as they are pushed.

The Readable stream pushes 'Hello' then 'World' as separate chunks. Each 'data' event logs one chunk, so console.log prints each chunk on its own line.

📝 Syntax

intermediate

Which option correctly creates a Writable stream that logs data?

Which code snippet correctly creates a Writable stream that logs each chunk it receives?

A

import { Writable } from 'stream';
const writable = new Writable({
  write(chunk) {
    console.log(chunk.toString());
  }
});

B

import { Writable } from 'stream';
const writable = new Writable({
  write(chunk, encoding) {
    console.log(chunk.toString());
    callback();
  }
});

C

import { Writable } from 'stream';
const writable = new Writable({
  write(chunk, encoding, callback) {
    console.log(chunk.toString());
    callback();
  }
});

D

import { Writable } from 'stream';
const writable = new Writable({
  write(chunk, encoding, callback) {
    console.log(chunk);
  }
});

💡 Hint

The write method must accept three arguments and call callback when done.

The write method requires three parameters: chunk, encoding, and callback. It must call callback() to signal completion. Option C follows this correctly.

❓ state_output

advanced

What is the output of this Transform stream?

Given this Transform stream that uppercases input, what will be the final output printed?

Node.js

import { Transform } from 'stream';

const upperCaseTransform = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

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

A hello world

B HELLO WORLD

C HELLO\nWORLD

D HELLO \nWORLD

💡 Hint

Each write triggers a 'data' event with the transformed chunk.

The Transform stream uppercases each chunk separately. The two writes produce two 'data' events, printing 'HELLO ' and 'WORLD' on separate lines.

🔧 Debug

advanced

Why does this Duplex stream cause an error?

This Duplex stream code throws an error. What is the cause?

Node.js

import { Duplex } from 'stream';

const duplex = new Duplex({
  read(size) {
    this.push('data');
    this.push(null);
  },
  write(chunk, encoding, callback) {
    console.log(chunk.toString());
    callback();
  }
});

A The read method pushes null too early, causing an error.

B The write method does not call callback(), causing the stream to hang.

C The Duplex constructor requires a 'final' method, which is missing.

D The write method should not log data, causing a runtime error.

💡 Hint

Writable streams must call callback() in write method.

The write method must call callback() to signal completion. Missing this causes the stream to hang or error.

🧠 Conceptual

expert

Which stream type allows simultaneous reading and writing with independent data flows?

In Node.js streams, which type supports both reading and writing independently, allowing data to flow in both directions at the same time?

A Duplex stream

B Writable stream

C Transform stream

D Readable stream

💡 Hint

Think about streams that combine reading and writing capabilities.

Duplex streams support both reading and writing independently, allowing two-way data flow simultaneously.

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