Creating buffers in Node.js - Quick Revision & Summary

Recall & Review

beginner

What is a Buffer in Node.js?

A Buffer is a special object in Node.js used to store raw binary data. It helps handle data like files or network streams efficiently.

beginner

How do you create a Buffer from a string in Node.js?

Use Buffer.from('your string') to create a buffer containing the bytes of the string.

beginner

What does Buffer.alloc(size) do?

It creates a new Buffer of the given size in bytes, filled with zeros. Useful when you need a fixed-size buffer.

intermediate

Why should you avoid using Buffer(size) constructor in modern Node.js?

Because it creates uninitialized memory which can contain old data. Use Buffer.alloc(size) for safety.

beginner

How can you create a Buffer from an array of bytes?

Use Buffer.from([byte1, byte2, ...]) to create a buffer containing those bytes.

Which method creates a zero-filled Buffer of a specific size?

A Buffer.create(size)

B Buffer.from(size)

C Buffer.alloc(size)

D Buffer.new(size)

Buffer.alloc(size) creates a Buffer filled with zeros. Buffer.from expects data, not size.

How do you create a Buffer from the string 'hello'?

A Buffer.from('hello')

B new Buffer('hello')

C Buffer.alloc('hello')

D Buffer.create('hello')

Buffer.from('hello') creates a Buffer containing the bytes of the string 'hello'.

Why is using Buffer(size) constructor discouraged?

A It is slower than Buffer.alloc

B It creates uninitialized memory which may contain sensitive data

C It does not create a Buffer

D It only works with strings

Buffer(size) creates uninitialized memory which can contain old data, risking security.

Which of these creates a Buffer from an array of bytes [1, 2, 3]?

A Buffer.from([1,2,3])

B Buffer.alloc([1,2,3])

C Buffer.new([1,2,3])

D Buffer.create([1,2,3])

Buffer.from(array) creates a Buffer containing the bytes from the array.

What type of data does a Buffer store?

A Only numbers

B Text only

C JavaScript objects

D Raw binary data

Buffers store raw binary data, useful for files, network data, and more.

Explain how to create a Buffer from a string and why it might be useful.

Think about turning text into bytes for processing.

Describe the difference between Buffer.alloc(size) and Buffer(size) and why one is preferred.

Consider memory safety and old data exposure.

Practice

1. What does Buffer.alloc(10) do in Node.js?

easy

A. Creates a buffer of 10 bytes filled with zeros

B. Creates a buffer of 10 bytes filled with random data

C. Creates a buffer from a string of length 10

D. Creates an empty array of length 10

Solution

1. Step 1: Understand Buffer.alloc usage

   Buffer.alloc(size) creates a buffer of the given size filled with zeros.

2. Step 2: Analyze the argument 10

   The argument 10 means the buffer will have 10 bytes, all initialized to zero.

3. Final Answer:

   Creates a buffer of 10 bytes filled with zeros -> Option A

4. Quick Check:

   Buffer.alloc(10) = zero-filled buffer [OK]

Hint: Buffer.alloc creates zero-filled buffer of given size [OK]

Common Mistakes:

• Thinking Buffer.alloc fills with random data
• Confusing Buffer.alloc with Buffer.from
• Assuming it creates an empty array

2. Which of the following is the correct syntax to create a buffer from the string 'hello'?

easy

A. Buffer.alloc('hello')

B. Buffer.from('hello')

C. new Buffer('hello')

D. Buffer.create('hello')

Solution

1. Step 1: Recall correct Buffer creation methods

   In modern Node.js, Buffer.from(string) creates a buffer from a string.

2. Step 2: Check options

   Buffer.alloc expects a size number, new Buffer is deprecated, and Buffer.create does not exist.

3. Final Answer:

   Buffer.from('hello') -> Option B

4. Quick Check:

   Buffer.from(string) creates buffer from string [OK]

Hint: Use Buffer.from(string) to create buffer from text [OK]

Common Mistakes:

• Using Buffer.alloc with string argument
• Using deprecated new Buffer() constructor
• Assuming Buffer.create exists

3. What will be the output of the following code?

const buf = Buffer.from('abc');
console.log(buf.length);

medium

A. Error

B. 6

C. undefined

D. 3

Solution

1. Step 1: Create buffer from string 'abc'

   Buffer.from('abc') creates a buffer with bytes representing 'a', 'b', 'c'.

2. Step 2: Check buffer length

   The length property returns the number of bytes, which is 3 for 'abc'.

3. Final Answer:

   3 -> Option D

4. Quick Check:

   Buffer length of 'abc' = 3 [OK]

Hint: Buffer length equals number of bytes in string [OK]

Common Mistakes:

• Assuming length is number of characters times 2
• Expecting undefined or error
• Confusing length with string length property

4. Identify the error in this code snippet:

const buf = Buffer.alloc('5');
console.log(buf.length);

medium

A. Buffer.alloc does not have length property

B. Buffer.alloc cannot be used without 'new'

C. Buffer.alloc expects a number, not a string

D. No error, code runs fine

Solution

1. Step 1: Check Buffer.alloc argument type

   Buffer.alloc expects a number for size, but '5' is a string.

2. Step 2: Understand type coercion in Buffer.alloc

   Passing a string causes a TypeError because size must be a number.

3. Final Answer:

   Buffer.alloc expects a number, not a string -> Option C

4. Quick Check:

   Buffer.alloc('5') causes type error [OK]

Hint: Pass number, not string, to Buffer.alloc size [OK]

Common Mistakes:

• Using string instead of number for size
• Thinking Buffer.alloc needs 'new' keyword
• Assuming length property is missing

5. You want to create a buffer from an array of bytes [72, 101, 108, 108, 111] representing 'Hello'. Which code correctly creates this buffer and converts it back to a string?

hard

A. const buf = Buffer.from([72,101,108,108,111]); console.log(buf.toString());

B. const buf = Buffer.alloc([72,101,108,108,111]); console.log(buf.toString());

C. const buf = Buffer.from('72,101,108,108,111'); console.log(buf.toString());

D. const buf = Buffer.alloc(5); buf.write([72,101,108,108,111]); console.log(buf.toString());

Solution

1. Step 1: Create buffer from array of bytes

   Buffer.from(array) creates a buffer from an array of byte values correctly.

2. Step 2: Convert buffer back to string

   buf.toString() converts the buffer bytes to the string 'Hello'.

3. Step 3: Analyze other options

   Using Buffer.alloc([72,101,108,108,111]) is wrong because alloc expects a number. Using Buffer.from('72,101,108,108,111') creates a buffer from the string of numbers, not bytes. Using buf.write([72,101,108,108,111]) is invalid as write doesn't accept arrays directly.

4. Final Answer:

   const buf = Buffer.from([72,101,108,108,111]); console.log(buf.toString()); -> Option A

5. Quick Check:

   Buffer.from(array) + toString() = 'Hello' [OK]

Hint: Use Buffer.from(array) to create buffer from bytes [OK]

Common Mistakes:

• Using Buffer.alloc with array argument
• Passing string of numbers instead of array
• Trying to write array directly into buffer