Buffer and streams relationship in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

🧠 Conceptual

intermediate

What is the role of a Buffer in Node.js streams?

In Node.js, when working with streams, what is the main purpose of a Buffer?

A It temporarily holds chunks of data to manage flow between fast and slow streams.

B It permanently stores all data from a stream for later use.

C It converts streams into JSON objects automatically.

D It encrypts data passing through the stream for security.

💡 Hint

Think about how data flows smoothly between parts that work at different speeds.

A Buffer in Node.js streams temporarily stores chunks of data to help manage the flow between fast data producers and slower consumers. This prevents data loss or overload.

❓ component_behavior

intermediate

What happens when a readable stream's internal buffer is full?

Consider a readable stream in Node.js. What occurs when its internal buffer reaches its highWaterMark limit?

A The stream discards new incoming data until space is available.

B The stream throws an error and closes immediately.

C The stream pauses reading from the source until the buffer is drained.

D The stream automatically increases the buffer size without pausing.

💡 Hint

Think about how streams prevent memory overload by controlling reading speed.

When the internal buffer hits the highWaterMark, the readable stream pauses reading from the source to prevent memory overload until some data is consumed and the buffer has space again.

📝 Syntax

advanced

Identify the correct way to create a Buffer from a stream chunk

Given a chunk of data from a readable stream, which code correctly creates a Buffer from it in Node.js?

Node.js

stream.on('data', (chunk) => {
  // create buffer here
});

A const buf = new Buffer(chunk);

B const buf = Buffer.from(chunk);

C const buf = Buffer.alloc(chunk);

D const buf = Buffer.create(chunk);

💡 Hint

Use the modern, safe method to create buffers from data.

Buffer.from() is the recommended way to create a Buffer from existing data like a stream chunk. The new Buffer() constructor is deprecated, and Buffer.alloc() creates an empty buffer of a specified size.

❓ state_output

advanced

What is the output when piping a readable stream to a writable stream with backpressure?

Consider this Node.js code snippet: const { Readable, Writable } = require('stream'); const readable = Readable.from(['a', 'b', 'c']); const writable = new Writable({ write(chunk, encoding, callback) { setTimeout(() => { console.log(chunk.toString()); callback(); }, 100); } }); readable.pipe(writable); What will be the order and timing of the console output?

A The letters 'a', 'b', 'c' print in order with about 100ms delay between each.

B All letters print immediately at once without delay.

C Only 'a' prints, then the program stops due to backpressure.

D The letters print in reverse order: 'c', 'b', 'a'.

💡 Hint

Think about how backpressure slows down writing but keeps order.

The writable stream simulates slow writing with a 100ms delay per chunk. Backpressure causes the readable stream to wait, so chunks print in order with delays.

🔧 Debug

expert

Why does this stream pipeline cause a memory leak?

Examine this Node.js code: const fs = require('fs'); const { Transform } = require('stream'); const readStream = fs.createReadStream('largefile.txt'); const transformStream = new Transform({ transform(chunk, encoding, callback) { // process chunk callback(null, chunk); } }); readStream.pipe(transformStream); // No pipe to writable stream or data event listener Why might this code cause a memory leak?

A Because the pipe method requires a third argument to work properly.

B Because the transform stream is missing the flush method.

C Because the file 'largefile.txt' does not exist, causing an error.

D Because the readable stream's data is not consumed, its internal buffer fills up indefinitely.

💡 Hint

Think about what happens if data is produced but never read or consumed.

If a readable stream pipes into a transform stream but the transform stream's output is not consumed (no pipe or data listener), the internal buffers fill up, causing a memory leak.

Practice

1. What is the main role of a Buffer in Node.js streams?

easy

A. Convert data to strings automatically

B. Send data directly to the network

C. Temporarily store raw data chunks in memory

D. Manage file system permissions

Solution

1. Step 1: Understand Buffer purpose

   A Buffer holds raw binary data temporarily in memory before processing or sending.

2. Step 2: Compare Buffer with other options

   Buffers do not send data or manage permissions; they just hold data chunks.

3. Final Answer:

   Temporarily store raw data chunks in memory -> Option C

4. Quick Check:

   Buffer = temporary data holder [OK]

Hint: Buffers hold data chunks temporarily in memory [OK]

Common Mistakes:

• Thinking Buffer sends data directly
• Confusing Buffer with string conversion
• Assuming Buffer manages permissions

2. Which of the following is the correct way to create a Buffer from a string in Node.js?

easy

A. const buf = Buffer.from('hello');

B. const buf = new Buffer('hello');

C. const buf = Buffer.create('hello');

D. const buf = Buffer.string('hello');

Solution

1. Step 1: Recall Buffer creation syntax

   Since Node.js v6+, Buffer.from() is the recommended way to create buffers from strings.

2. Step 2: Identify deprecated or invalid methods

   new Buffer() is deprecated; Buffer.create() and Buffer.string() do not exist.

3. Final Answer:

   const buf = Buffer.from('hello'); -> Option A

4. Quick Check:

   Use Buffer.from() to create buffers [OK]

Hint: Use Buffer.from() to create buffers from strings [OK]

Common Mistakes:

• Using deprecated new Buffer() constructor
• Trying non-existent Buffer methods
• Confusing Buffer creation with other APIs

3. Consider this code snippet using a readable stream and Buffer:

const { Readable } = require('stream');
const readable = Readable.from(['Hello', ' ', 'World']);
readable.on('data', (chunk) => {
  console.log(Buffer.isBuffer(chunk));
});

What will be the output?

medium

A. false false false

B. true true true

C. true false true

D. false true false

Solution

1. Step 1: Understand Readable.from behavior

   Readable.from emits chunks as strings by default when given strings.

2. Step 2: Check Buffer.isBuffer for each chunk

   Each chunk ('Hello', ' ', 'World') is a string, so Buffer.isBuffer(chunk) returns false each time.

3. Final Answer:

   false false false -> Option A

4. Quick Check:

   Readable.from strings emit strings, not Buffers [OK]

Hint: Readable.from strings emit strings by default [OK]

Common Mistakes:

• Assuming chunks are Buffers, not strings
• Expecting mixed true/false outputs
• Not knowing Buffer.isBuffer usage

4. Identify the error in this code that reads a file stream and logs data chunks:

const fs = require('fs');
const stream = fs.createReadStream('file.txt');
stream.on('data', (chunk) => {
  console.log(chunk.toString('utf8'));
});
stream.on('end', () => {
  console.log('Done');
});

medium

A. The 'end' event should be 'close'

B. Missing error event handler for the stream

C. createReadStream requires a callback function

D. Using toString() on chunk causes a crash

Solution

1. Step 1: Review stream event handlers

   The code handles 'data' and 'end' events correctly but lacks an 'error' event handler.

2. Step 2: Understand importance of error handling

   Without an 'error' handler, stream errors (like file not found) will crash the program.

3. Final Answer:

   Missing error event handler for the stream -> Option B

4. Quick Check:

   Always add 'error' handler on streams [OK]

Hint: Always add 'error' event handler to streams [OK]

Common Mistakes:

• Ignoring error events on streams
• Confusing 'end' and 'close' events
• Thinking toString() causes errors

5. You want to process a large file efficiently by reading it in chunks and converting each chunk to uppercase before writing to another file. Which approach best uses Buffers and streams together?

hard

A. Read the entire file into a Buffer, convert to uppercase, then write all at once

B. Convert the file to string first, then create a Buffer for writing

C. Use synchronous file read and write with Buffer conversions

D. Use a readable stream to read chunks as Buffers, transform each chunk to uppercase string, then write using a writable stream

Solution

1. Step 1: Understand efficient large file processing

   Reading in chunks with streams avoids loading the whole file into memory.

2. Step 2: Use Buffers with streams for chunk processing

   Readable streams provide Buffers; convert each chunk to uppercase string, then write with writable stream.

3. Step 3: Compare other options

   Reading entire file at once or synchronous methods are inefficient for large files.

4. Final Answer:

   Use a readable stream to read chunks as Buffers, transform each chunk to uppercase string, then write using a writable stream -> Option D

5. Quick Check:

   Streams + Buffers + transform chunks = efficient processing [OK]

Hint: Process large files chunk-by-chunk with streams and Buffers [OK]

Common Mistakes:

• Loading entire file into memory
• Using synchronous file operations
• Ignoring chunk-by-chunk processing benefits