Writing data with Writable streams in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output when writing data to a Writable stream?

Consider the following Node.js code using a Writable stream. What will be printed to the console?

Node.js

import { Writable } from 'stream';

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

writable.write('Hello');
writable.write('World');
writable.end();

A

Hello
World

B HelloWorld

C undefinedundefined

D Error: write method missing callback

💡 Hint

Remember that each write call triggers the write method separately.

Each call to writable.write sends a chunk to the write method, which logs it with a newline. So 'Hello' and 'World' are printed on separate lines.

📝 Syntax

intermediate

Which option correctly implements a Writable stream that converts input to uppercase?

Select the option that correctly creates a Writable stream which converts all written data to uppercase before logging it.

A

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

B

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

C

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

D

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

💡 Hint

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

Option A correctly defines write with (chunk, encoding, callback) and calls callback after logging uppercase string. Others miss callback or use wrong chunk methods.

🔧 Debug

advanced

Why does this Writable stream code cause a runtime error?

Examine the code below. Why does it throw an error when writing data?

Node.js

import { Writable } from 'stream';

const writable = new Writable({
  write(chunk, encoding, callback) {
    const data = chunk.toUpperCase();
    console.log(data);
    callback();
  }
});

writable.write('test');

A The write method must be async to handle string data properly.

B chunk is a Buffer, so chunk.toUpperCase() is not a function, causing a TypeError.

C Missing callback call causes the stream to hang and throw an error.

D The Writable constructor requires a 'read' method, which is missing.

💡 Hint

Check the type of chunk and what methods it supports.

chunk is a Buffer object, which does not have a toUpperCase method. You must convert it to string first.

❓ state_output

advanced

What is the final value of 'data' after writing to this Writable stream?

Given the following code, what will be the value of the variable 'data' after all writes complete?

Node.js

import { Writable } from 'stream';

let data = '';
const writable = new Writable({
  write(chunk, encoding, callback) {
    data += chunk.toString();
    callback();
  }
});

writable.write('Node');
writable.write('JS');
writable.end();

A "undefined"

B "Node JS"

C "Node\nJS"

D "NodeJS"

💡 Hint

Consider how the chunks are concatenated without extra characters.

Each chunk is converted to string and appended directly, so 'Node' + 'JS' = 'NodeJS'. No spaces or newlines are added.

🧠 Conceptual

expert

Which option best explains backpressure handling in Writable streams?

In Node.js Writable streams, what does the return value of the write() method indicate and how should it be handled?

A write() returns true when the internal buffer is full; the producer should immediately write more data to avoid blocking.

B write() returns undefined; backpressure is managed by the operating system, not the stream.

C write() returns false when the internal buffer is full; the producer should wait for the 'drain' event before writing more data.

D write() always returns true; backpressure is handled automatically without developer intervention.

💡 Hint

Think about how streams signal when they can accept more data.

When write() returns false, it signals the buffer is full and the producer must wait for 'drain' event before writing more to avoid memory issues.