Node.js Buffers

A Buffer in Node.js is a temporary storage area in memory used to hold raw binary data. When working with streams, files, network communications, or any data that is transmitted or read in chunks, Node.js uses Buffers to handle that data before it is processed or converted into a usable format like a string.

Unlike regular JavaScript strings, Buffers work directly with raw bytes — the ones and zeros that computers actually understand at the lowest level.

Why Do Buffers Exist?

JavaScript was originally designed to handle text in browsers. But Node.js works in environments where binary data is common — reading image files, handling TCP connections, processing audio, or receiving data from a network stream. Regular JavaScript strings are not designed for binary data. Buffers fill this gap.

Think of a Buffer like a physical pipeline that temporarily holds water (data) while it flows from one place to another. The water moves in chunks — not all at once — and the pipeline holds each chunk until it is ready to be processed.

Creating a Buffer

Buffer.alloc() – Create an Empty Buffer of Fixed Size

Creates a Buffer filled with zeros of the specified byte length:

const buf = Buffer.alloc(5);

console.log(buf);
// Output: <Buffer 00 00 00 00 00>

console.log(buf.length);
// Output: 5

Buffer.from() – Create a Buffer from a String or Array

Creates a Buffer from existing data — such as a string:

const buf = Buffer.from("Hello");

console.log(buf);
// Output: <Buffer 48 65 6c 6c 6f>

console.log(buf.length);
// Output: 5

Each character is stored as its ASCII (or UTF-8) byte value. The letter "H" is 48 in hexadecimal, which equals decimal 72.

Buffer.allocUnsafe() – Fast Buffer Without Initialization

const buf = Buffer.allocUnsafe(10);
// May contain old memory data — must be filled before use
buf.fill(0); // Fill with zeros to clean it
console.log(buf);

allocUnsafe is faster than alloc because it does not zero out the memory, but it should only be used if the buffer will be completely overwritten before being read.

Writing to a Buffer

const buf = Buffer.alloc(10);

buf.write("Hi there!");

console.log(buf);
// <Buffer 48 69 20 74 68 65 72 65 21 00>

console.log(buf.toString());
// Output: Hi there!

Reading from a Buffer

Converting a Buffer to a String

const buf = Buffer.from("Node.js Buffers");

console.log(buf.toString());
// Output: Node.js Buffers

console.log(buf.toString('utf8', 0, 4));
// Output: Node (only reads first 4 bytes)

The toString() method accepts an optional encoding and start/end byte positions.

Buffer Encodings

Buffers support multiple character encodings:

const buf = Buffer.from("Hello");

console.log(buf.toString('utf8'));    // Hello
console.log(buf.toString('hex'));     // 48656c6c6f
console.log(buf.toString('base64')); // SGVsbG8=

Comparing Buffers

const buf1 = Buffer.from("ABC");
const buf2 = Buffer.from("ABC");
const buf3 = Buffer.from("XYZ");

console.log(buf1.equals(buf2)); // true
console.log(buf1.equals(buf3)); // false

Copying Buffers

const source = Buffer.from("Hello World");
const destination = Buffer.alloc(5);

// Copy 5 bytes from source (starting at index 0) into destination
source.copy(destination, 0, 0, 5);

console.log(destination.toString());
// Output: Hello

Slicing a Buffer

buffer.slice() returns a new Buffer that references the same memory as the original, but only covers a portion of it:

const buf = Buffer.from("Hello World");

const slice = buf.slice(6, 11);
console.log(slice.toString());
// Output: World

Be careful — since a slice shares memory with the original Buffer, modifying one affects the other. Use Buffer.from(buf.slice(...)) to create an independent copy.

Concatenating Buffers

const buf1 = Buffer.from("Hello, ");
const buf2 = Buffer.from("World!");

const combined = Buffer.concat([buf1, buf2]);

console.log(combined.toString());
// Output: Hello, World!

Buffer and File Operations

When reading files without specifying an encoding, Node.js returns a Buffer:

const fs = require('fs');

fs.readFile('image.png', function(err, data) {
  if (err) throw err;
  console.log(typeof data); // object
  console.log(Buffer.isBuffer(data)); // true
  console.log("Image size in bytes:", data.length);
});

For binary files like images, audio, or video, working with the raw Buffer directly is necessary before saving or transmitting the file.

Checking Buffer Size Limits

console.log(Buffer.poolSize); // Default pool size: 8192 bytes
console.log(buffer.constants.MAX_LENGTH); // Maximum buffer size on the platform

Key Points

• A Buffer is a fixed-size chunk of memory used to temporarily store raw binary data.
• Buffers are used when dealing with streams, files, network data, and binary operations.
• Buffer.from() creates a Buffer from strings or arrays; Buffer.alloc() creates an empty Buffer.
• Use .toString(encoding) to convert a Buffer to a readable string.
• Supported encodings include utf8, hex, base64, and ascii.
• Buffers can be compared, sliced, copied, and concatenated.
• Reading binary files (images, PDFs) returns a Buffer, not a string.
• Buffers are closely linked to Streams, which are introduced in the next topic.