Stream backpressure concept in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the main purpose of backpressure in Node.js streams?

Why do streams use backpressure in Node.js?

A To speed up the data transfer between streams regardless of the writable stream's capacity

B To close the stream automatically when data size exceeds a limit

C To buffer all data in memory before writing it to the destination

D To control the flow of data so the writable stream is not overwhelmed by the readable stream

💡 Hint

Think about what happens if data is sent faster than it can be processed.

Backpressure helps prevent the writable stream from being flooded with data it cannot handle immediately. It signals the readable stream to slow down or pause until the writable stream is ready again.

❓ component_behavior

intermediate

What happens when writable.write() returns false in a Node.js stream?

In Node.js streams, if writable.write(chunk) returns false, what does it mean for the data flow?

A The writable stream has ended and cannot accept more data

B The chunk was written successfully and the stream is ready for more data immediately

C The internal buffer is full; the writable stream asks the readable stream to pause sending data

D The chunk was rejected and will be lost

💡 Hint

Consider what the return value of writable.write() indicates about the buffer state.

When writable.write() returns false, it signals that the internal buffer is full. The readable stream should pause to avoid overwhelming the writable stream.

❓ state_output

advanced

What is the output of this Node.js stream code regarding backpressure?

Consider this code snippet using streams in Node.js. What will be logged to the console?

Node.js

const { Readable, Writable } = require('stream');

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

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

const canWriteMore = writable.write('chunk1');
console.log('Can write more after chunk1:', canWriteMore);

writable.on('drain', () => {
  console.log('Drain event fired');
});

A Can write more after chunk1: false

B

Writing: chunk1
Can write more after chunk1: true

C

Writing: chunk1
Can write more after chunk1: false
Drain event fired

D

Writing: chunk1
Drain event fired
Can write more after chunk1: true

💡 Hint

Check what writable.write returns when the internal buffer is empty.

Since the writable stream's internal buffer is empty and the write is synchronous, writable.write returns true immediately. The 'drain' event does not fire because the buffer never fills.

🔧 Debug

advanced

Why does this Node.js stream code cause a memory leak?

This code reads from a file and writes to another file using streams. Why might it cause a memory leak related to backpressure?

Node.js

const fs = require('fs');

const readable = fs.createReadStream('input.txt');
const writable = fs.createWriteStream('output.txt');

readable.on('data', (chunk) => {
  writable.write(chunk);
});

A Because writable.write is called without checking its return value, causing the readable stream to keep emitting data even if writable buffer is full

B Because the readable stream is not paused after the 'end' event

C Because the writable stream is not closed after writing

D Because the 'data' event is not removed after the first chunk

💡 Hint

Think about what happens if writable.write returns false but readable keeps emitting data.

If writable.write returns false, the writable stream's buffer is full. Without pausing the readable stream, data keeps accumulating in memory causing a leak.

📝 Syntax

expert

Which option correctly implements backpressure handling in a Node.js stream pipe?

Given a readable and writable stream, which code snippet correctly handles backpressure to avoid memory issues?

A

readable.on('data', (chunk) => {
  if (!writable.write(chunk)) {
    readable.pause();
  }
});
writable.on('drain', () => {
  readable.resume();
});

B

readable.on('data', (chunk) => {
  writable.write(chunk);
});
writable.on('drain', () => {
  readable.resume();
});

C

readable.pipe(writable);
readable.pause();
writable.resume();

D

readable.pipe(writable);
writable.on('drain', () => {
  readable.pause();
});

💡 Hint

Backpressure requires pausing readable when writable buffer is full and resuming on drain.

Option A checks writable.write's return value and pauses the readable stream if false, then resumes it on 'drain'. This correctly manages backpressure.