Buffer and streams relationship in Node.js - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a Buffer from a string.

Node.js

const buf = Buffer.[1]('Hello');

Drag options to blanks, or click blank then click option'

Afrom

Balloc

Cwrite

Dslice

Attempts:

3 left

💡 Hint

Common Mistakes

Using Buffer.alloc instead of Buffer.from

Trying to use Buffer.write directly

The Buffer.from() method creates a new Buffer containing the given string.

2fill in blank

medium

Complete the code to read data from a readable stream into a Buffer.

Node.js

stream.on('data', chunk => {
  const buf = Buffer.[1](chunk);
});

Drag options to blanks, or click blank then click option'

Aalloc

Bslice

Cconcat

Dfrom

Attempts:

3 left

💡 Hint

Common Mistakes

Using Buffer.alloc which creates empty buffer

Trying to use Buffer.concat on single chunk

Each chunk from a stream is a Buffer or can be converted to one using Buffer.from().

3fill in blank

hard

Fix the error in the code to properly concatenate multiple Buffer chunks from a stream.

Node.js

let buffers = [];
stream.on('data', chunk => {
  buffers.push(chunk);
});
stream.on('end', () => {
  const result = Buffer.[1](buffers);
});

Drag options to blanks, or click blank then click option'

Afrom

Bconcat

Calloc

Dslice

Attempts:

3 left

💡 Hint

Common Mistakes

Using Buffer.from on array of buffers

Using Buffer.alloc which creates empty buffer

Buffer.concat() combines an array of Buffers into one Buffer.

4fill in blank

hard

Fill both blanks to create a writable stream that writes Buffer data to a file.

Node.js

const fs = require('fs');
const writable = fs.createWriteStream('output.txt');
writable.[1](Buffer.[2]('Data to write'));

Drag options to blanks, or click blank then click option'

Awrite

Bfrom

Calloc

Dend

Attempts:

3 left

💡 Hint

Common Mistakes

Using Buffer.alloc instead of Buffer.from

Using end instead of write for sending data

The write method sends data to the writable stream, and Buffer.from() creates a Buffer from the string.

5fill in blank

hard

Fill all three blanks to read data from a readable stream, concatenate buffers, and convert to string.

Node.js

let chunks = [];
readable.[1]('data', chunk => {
  chunks.[2](chunk);
});
readable.on('end', () => {
  const buffer = Buffer.[3](chunks);
  console.log(buffer.toString());
});

Drag options to blanks, or click blank then click option'

Aon

Bpush

Cconcat

Dwrite

Attempts:

3 left

💡 Hint

Common Mistakes

Using write instead of on for event

Using alloc instead of concat

Using pop instead of push

Use on to listen for data events, push to add chunks to array, and Buffer.concat to combine buffers.

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