Node.js Buffer Module

What is the Buffer Module?

Node.js provides the Buffer class as a global object, so you don't need to require or import it explicitly.

Note:

Getting Started with Buffers

Basic Buffer Example

// Create a buffer from a string const buf = Buffer.from('Hello, Node.js!');
// Buffers can be converted to strings console.log(buf.toString()); // 'Hello, Node.js!'
// Access individual bytes console.log(buf[0]); // 72 (ASCII for 'H')
// Buffers have a fixed length console.log(buf.length); // 15

Creating Buffers

// Create a buffer of 10 bytes filled with zeros const buffer1 = Buffer.alloc(10);
console.log(buffer1);

This is faster than

// Create an uninitialized buffer of 10 bytes const buffer2 = Buffer.allocUnsafe(10);
console.log(buffer2);
// Fill the buffer with zeros for security buffer2.fill(0);
console.log(buffer2);

Warning:

// Create a buffer from a string const buffer3 = Buffer.from('Hello, World!');
console.log(buffer3);
console.log(buffer3.toString());
// Create a buffer from an array of integers const buffer4 = Buffer.from([65, 66, 67, 68, 69]);
console.log(buffer4);
console.log(buffer4.toString());
// Create a buffer from another buffer const buffer5 = Buffer.from(buffer4);
console.log(buffer5);

Using Buffers

Writing to Buffers

// Create an empty buffer const buffer = Buffer.alloc(10);
// Write a string to the buffer buffer.write('Hello');
console.log(buffer);
console.log(buffer.toString());
// Write bytes at specific positions buffer[5] = 44; // ASCII for ','
buffer[6] = 32; // ASCII for space buffer.write('Node', 7);
console.log(buffer.toString());

Reading from Buffers

// Create a buffer from a string const buffer = Buffer.from('Hello, Node.js!');
// Read the entire buffer as a string console.log(buffer.toString());
// Read a portion of the buffer (start at position 7, end before position 11)
console.log(buffer.toString('utf8', 7, 11));
// Read a single byte console.log(buffer[0]);
// Convert the ASCII code to a character console.log(String.fromCharCode(buffer[0]));

Iterating Through Buffers

// Create a buffer from a string const buffer = Buffer.from('Hello');
// Iterate using for...of loop for (const byte of buffer) {
console.log(byte);
}
// Iterate using forEach buffer.forEach((byte, index) => {
console.log(`Byte at position ${index}: ${byte}`);
});

Buffer Methods

const buffer1 = Buffer.from('ABC');
const buffer2 = Buffer.from('BCD');
const buffer3 = Buffer.from('ABC');
console.log(Buffer.compare(buffer1, buffer2));
console.log(Buffer.compare(buffer2, buffer1));
console.log(Buffer.compare(buffer1, buffer3));
buffer.copy()

// Create source and target buffers const source = Buffer.from('Hello, World!');
const target = Buffer.alloc(source.length);
// Copy from source to target source.copy(target);
console.log(target.toString());
// Create a target buffer for partial copy const partialTarget = Buffer.alloc(5);
// Copy only part of the source (starting at index 7)
source.copy(partialTarget, 0, 7);
console.log(partialTarget.toString());
buffer.slice()

const buffer = Buffer.from('Hello, World!');
// Create a slice from position 7 to the end const slice = buffer.slice(7);
console.log(slice.toString());
// Create a slice from position 0 to 5 const slice2 = buffer.slice(0, 5);
console.log(slice2.toString());
// Important: slices share memory with original buffer slice[0] = 119; // ASCII for 'w' (lowercase)
console.log(slice.toString());
console.log(buffer.toString());

Note:

const buffer = Buffer.from('Hello, World!');
// Default encoding is UTF-8 console.log(buffer.toString());
// Specify encoding console.log(buffer.toString('utf8'));
// Decode only a portion of the buffer console.log(buffer.toString('utf8', 0, 5));
// Using different encodings const hexBuffer = Buffer.from('48656c6c6f', 'hex');
console.log(hexBuffer.toString());
const base64Buffer = Buffer.from('SGVsbG8=', 'base64');
console.log(base64Buffer.toString());
buffer.equals()

const buffer1 = Buffer.from('Hello');
const buffer2 = Buffer.from('Hello');
const buffer3 = Buffer.from('World');
console.log(buffer1.equals(buffer2));
console.log(buffer1.equals(buffer3));
console.log(buffer1 === buffer2);

Working with Encodings

// Create a string const str = 'Hello, World!';
// Convert to different encodings const utf8Buffer = Buffer.from(str, 'utf8');
console.log('UTF-8:', utf8Buffer);
const base64Str = utf8Buffer.toString('base64');
console.log('Base64 string:', base64Str);
const hexStr = utf8Buffer.toString('hex');
console.log('Hex string:', hexStr);
// Convert back to original const fromBase64 = Buffer.from(base64Str, 'base64').toString('utf8');
console.log('From Base64:', fromBase64);
const fromHex = Buffer.from(hexStr, 'hex').toString('utf8');
console.log('From Hex:', fromHex);

: Multi - byte encoded Unicode characters (default)

: ASCII characters only (7 - bit)

: Latin - 1 encoding (ISO 8859 - 1)

ucs2/utf16le
: 2 or 4 bytes, little - endian encoded Unicode characters

Advanced Buffer Operations

Concatenating Buffers

Example

const buf1 = Buffer.from('Hello, ');
const buf2 = Buffer.from('Node.js!');
// Concatenate buffers const combined = Buffer.concat([buf1, buf2]);
console.log(combined.toString()); // 'Hello, Node.js!'
// With a maximum length parameter const partial = Buffer.concat([buf1, buf2], 5);
console.log(partial.toString()); // 'Hello'

Searching in Buffers

Example

const buf = Buffer.from('Hello, Node.js is awesome!');
// Find the first occurrence of a value console.log(buf.indexOf('Node')); // 7
// Check if buffer contains a value console.log(buf.includes('awesome')); // true
// Find the last occurrence of a value console.log(buf.lastIndexOf('e')); // 24

Buffer and Streams

Example

const fs = require('fs');
const { Transform } = require('stream');
// Create a transform stream that processes data in chunks const transformStream = new Transform({
transform(chunk, encoding, callback) {
// Process each chunk (which is a Buffer)
const processed = chunk.toString().toUpperCase();
this.push(Buffer.from(processed));
callback();
}
});
// Create a read stream from a file const readStream = fs.createReadStream('input.txt');
// Create a write stream to a file const writeStream = fs.createWriteStream('output.txt');
// Process the file in chunks readStream.pipe(transformStream).pipe(writeStream);

Buffer and File System

const fs = require('fs');
// Write buffer to file const writeBuffer = Buffer.from('Hello, Node.js!');
fs.writeFile('buffer.txt', writeBuffer, (err) => {
if (err) throw err;
console.log('File written successfully');
// Read file into buffer fs.readFile('buffer.txt', (err, data) => {
if (err) throw err;
// 'data' is a buffer console.log('Read buffer:', data);
console.log('Buffer content:', data.toString());
// Read only part of the file into a buffer const smallBuffer = Buffer.alloc(5);
fs.open('buffer.txt', 'r', (err, fd) => {
if (err) throw err;
// Read 5 bytes starting at position 7 fs.read(fd, smallBuffer, 0, 5, 7, (err, bytesRead, buffer) => {
if (err) throw err;
console.log('Partial read:', buffer.toString());

fs.close(fd, (err) => {
if (err) throw err;
});
});
});
});
});

Buffer Performance Considerations

Memory Usage: