Reading and writing buffer data in Node.js - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Buffer write and read code?

Consider the following Node.js code that writes a string to a buffer and then reads it back. What will be logged to the console?

Node.js

const buf = Buffer.alloc(10);
buf.write('hello');
console.log(buf.toString('utf8', 0, 5));

A "\u0000\u0000\u0000\u0000\u0000"

B "hello\u0000"

C "hellohello"

D "hello"

💡 Hint

Remember that Buffer.alloc creates a buffer filled with zeros and write returns the number of bytes written.

The code writes 'hello' into the buffer starting at index 0. Then it reads the first 5 bytes as a UTF-8 string, which matches 'hello'. The rest of the buffer remains zeros but is not included in the output.

❓ component_behavior

intermediate

What happens when you slice a Buffer and modify the slice?

Given this code, what will be the output after modifying the slice?

Node.js

const buf = Buffer.from('abcdef');
const slice = buf.slice(1, 4);
slice[0] = 120;
console.log(buf.toString());

A "abxdef"

B "abcdef"

C "xbcdef"

D "axcdef"

💡 Hint

Buffer slices share the same memory as the original buffer.

The slice covers indices 1 to 3 (characters 'b', 'c', 'd'). Changing slice[0] changes buf[1] to 120 (which is 'x'). So the original buffer becomes 'a', 'x', 'c', 'd', 'e', 'f'.

📝 Syntax

advanced

Which option correctly creates a Buffer from a hex string?

You want to create a Buffer from the hex string '48656c6c6f'. Which code snippet does this correctly?

A Buffer.from('48656c6c6f', 'utf8')

B Buffer.from('48656c6c6f', 'hex')

C Buffer.alloc('48656c6c6f', 'hex')

D Buffer.allocUnsafe('48656c6c6f')

💡 Hint

The encoding parameter tells Buffer how to interpret the string.

Buffer.from with 'hex' encoding interprets the string as hexadecimal bytes. Using 'utf8' treats it as normal text, which is incorrect here. Buffer.alloc and allocUnsafe do not accept string data as input.

🔧 Debug

advanced

Why does this Buffer write return 0 bytes written?

Look at this code snippet. Why does buf.write return 0?

Node.js

const buf = Buffer.alloc(5);
const bytesWritten = buf.write('hello world', 0, 5, 'utf8');
console.log(bytesWritten);

A Because the string is longer than the buffer size, so nothing is written.

B Because the length parameter is the max bytes to write, but the string is truncated and no bytes fit.

C Because the length parameter is the max bytes to write, but the string is longer and write returns the number of bytes actually written.

D Because the length parameter is less than the string length, so it writes only 5 bytes.

💡 Hint

Check the meaning of the length parameter in buf.write.

The length parameter limits how many bytes to write. The string 'hello world' is longer than 5 bytes, so only the first 5 bytes are written. The function returns the number of bytes written, which is 5, not 0. So the premise is wrong; the code returns 5, not 0.

❓ state_output

expert

What is the final content of the buffer after these operations?

Analyze the code and determine the final string content of the buffer.

Node.js

const buf = Buffer.alloc(6);
buf.write('abc');
buf.write('def', 3);
buf.fill('x', 1, 4);
console.log(buf.toString());

A "axxxef"

B "axxxxf"

C "abcxxx"

D "abcdef"

💡 Hint

Remember that fill replaces bytes in the specified range, and write overwrites bytes starting at the given offset.

First, 'abc' is written at index 0: [a,b,c,?, ?, ?]. Then 'def' is written at index 3: [a,b,c,d,e,f]. Then fill replaces bytes from index 1 to 4 (excluding 4) with 'x': indices 1,2,3 become 'x'. Final buffer: [a,x,x,x,e,f].

Practice

1. What is the primary purpose of a Buffer in Node.js?

easy

A. To manage HTTP requests automatically

B. To store JavaScript objects in memory

C. To hold raw binary data for reading and writing

D. To format strings for display in the console

Solution

1. Step 1: Understand what Buffer stores

   A Buffer is designed to hold raw binary data, not objects or formatted strings.

2. Step 2: Identify Buffer's main use

   Buffers allow reading and writing bytes directly, useful for binary data handling.

3. Final Answer:

   To hold raw binary data for reading and writing -> Option C

4. Quick Check:

   Buffer = raw binary data [OK]

Hint: Buffers store raw bytes, not objects or formatted text [OK]

Common Mistakes:

• Thinking Buffer stores JavaScript objects
• Confusing Buffer with string formatting tools
• Assuming Buffer manages HTTP requests

2. Which of the following is the correct way to create a Buffer of size 5 bytes filled with zeros?

easy

A. Buffer.new(5)

B. Buffer.alloc(5)

C. new Buffer(5, 0)

D. Buffer.create(5)

Solution

1. Step 1: Recall Buffer creation methods

   In modern Node.js, Buffer.alloc(size) creates a zero-filled buffer.

2. Step 2: Check other options

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

3. Final Answer:

   Buffer.alloc(5) -> Option B

4. Quick Check:

   Use Buffer.alloc for safe zero-filled buffers [OK]

Hint: Use Buffer.alloc(size) for zero-filled buffers [OK]

Common Mistakes:

• Using deprecated new Buffer() constructor
• Trying non-existent Buffer.new or Buffer.create methods
• Not initializing buffer contents

3. What will be the output of this code?

const buf = Buffer.from('abc');
console.log(buf[1]);

medium

A. 98

B. b

C. 1

D. undefined

Solution

1. Step 1: Understand Buffer.from and indexing

   Buffer.from('abc') creates a buffer with ASCII codes of 'a', 'b', 'c'. Index 1 is 'b'.

2. Step 2: Check what buf[1] returns

   Buffer indexes return the byte value (number), not the character. 'b' ASCII code is 98.

3. Final Answer:

   98 -> Option A

4. Quick Check:

   Buffer index returns byte code, not character [OK]

Hint: Buffer indexes return byte numbers, not characters [OK]

Common Mistakes:

• Expecting character instead of ASCII code
• Confusing index with string position
• Assuming buf[1] returns a string

4. Identify the error in this code snippet:

const buf = Buffer.alloc(3);
buf.write('hello');
console.log(buf.toString());

medium

A. Buffer size is too small for the string 'hello'

B. Buffer.alloc cannot be used with write method

C. toString() cannot be called on a Buffer

D. write method requires encoding argument

Solution

1. Step 1: Check buffer size vs string length

   Buffer.alloc(3) creates 3 bytes, but 'hello' needs 5 bytes to store fully.

2. Step 2: Understand write behavior

   write writes as many bytes as fit; here it truncates 'hello' to 'hel'.

3. Final Answer:

   Buffer size is too small for the string 'hello' -> Option A

4. Quick Check:

   Buffer too small truncates written string [OK]

Hint: Buffer must be large enough to hold full string [OK]

Common Mistakes:

• Thinking write needs encoding argument always
• Assuming toString() is invalid on Buffer
• Believing Buffer.alloc disallows write

5. You want to copy the first 4 bytes from one buffer src to another buffer dest starting at index 2 in dest. Which code correctly does this?

hard

A. dest.copy(src, 2, 0, 4);

B. dest.copy(src, 0, 2, 6);

C. src.copy(dest, 0, 2, 6);

D. src.copy(dest, 2, 0, 4);

Solution

1. Step 1: Understand Buffer.copy parameters

   The method is source.copy(target, targetStart, sourceStart, sourceEnd).

2. Step 2: Match parameters to requirement

   Copy from src starting at 0 to 4 bytes, into dest starting at index 2.

3. Final Answer:

   src.copy(dest, 2, 0, 4); -> Option D

4. Quick Check:

   source.copy(target, targetStart, sourceStart, sourceEnd) [OK]

Hint: source.copy(target, targetStart, sourceStart, sourceEnd) [OK]

Common Mistakes:

• Swapping source and target buffers
• Mixing up start and end indexes
• Using copy on wrong buffer object