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.