Reading and writing buffer data in Node.js - Step-by-Step Execution

Concept Flow - Reading and writing buffer data

Create Buffer

↓

Write Data to Buffer

↓

Read Data from Buffer

↓

Use or Display Data

↓

End

This flow shows how to create a buffer, write data into it, then read data back for use.

Execution Sample

Node.js

const buf = Buffer.alloc(5);
buf.write('Hello');
const readStr = buf.toString('utf8');
console.log(readStr);

This code creates a buffer of 5 bytes, writes 'Hello' into it, reads it back as a string, and prints it.

Execution Table

Step	Action	Buffer Content (hex)	Buffer Content (string)	Output
1	Create buffer of length 5	00 00 00 00 00
2	Write 'Hello' to buffer	48 65 6c 6c 6f	Hello
3	Read buffer as UTF-8 string	48 65 6c 6c 6f	Hello
4	Print read string	48 65 6c 6c 6f	Hello	Hello
5	End of execution	48 65 6c 6c 6f	Hello	Execution complete

💡 All steps completed; buffer data written and read successfully.

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	Final
buf	undefined	<Buffer 00 00 00 00 00>	<Buffer 48 65 6c 6c 6f>	<Buffer 48 65 6c 6c 6f>	<Buffer 48 65 6c 6c 6f>
readStr	undefined	undefined	undefined	Hello	Hello

Key Moments - 3 Insights

Why does the buffer initially contain zeros?

At step 1, Buffer.alloc creates a buffer filled with zeros for safety and predictability, as shown in the execution_table row 1.

What happens if you write a string longer than the buffer size?

The write method only writes up to the buffer's length. Extra characters are ignored, so the buffer content won't exceed its size (see step 2).

Why do we use toString('utf8') to read the buffer?

Buffers store raw bytes. toString('utf8') converts these bytes into readable text, as shown in step 3 reading 'Hello' from the buffer.

Visual Quiz - 3 Questions

Look at the execution_table at step 2. What is the buffer content in hex after writing 'Hello'?

A 68 65 6c 6c 6f

B 00 00 00 00 00

C 48 65 6c 6c 6f

D 48 65 6c 6c

💡 Hint

Check the 'Buffer Content (hex)' column at step 2 in the execution_table.

At which step does the variable 'readStr' get its value 'Hello'?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Look at the variable_tracker row for 'readStr' and see when it changes from undefined to 'Hello'.

If the buffer size was 3 instead of 5, what would be the output at step 4?

A Hello

B Hel

C He

D Error

💡 Hint

Recall that writing 'Hello' to a smaller buffer truncates to buffer length, shown in step 2 behavior.

Concept Snapshot

Buffer basics in Node.js:
- Create with Buffer.alloc(size)
- Write string with buf.write('text')
- Read string with buf.toString('utf8')
- Buffer size limits data stored
- Useful for handling raw binary data

Full Transcript

This lesson shows how Node.js buffers work by creating a buffer, writing a string into it, then reading it back as text. Initially, the buffer is empty and filled with zeros. Writing 'Hello' stores its bytes in the buffer. Reading converts bytes back to a string. The buffer size limits how much data can be stored. This helps handle raw data safely and efficiently.

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