Back to home

Node.js Buffers Explained

Published: Jul 4, 2024

Last updated: Jul 4, 2024


Today's post will walk through Node.js' Buffer object. This will be a prelude to the series on demystifying Node.js streams.

What are Node.js Buffer objects?

A Buffer in Node.js is a temporary storage area in memory used to hold raw binary data. It is a fixed-length sequence of bytes, similar to an array of integers, but corresponds to a raw memory allocation outside the V8 JavaScript engine.

Buffers are essential for handling raw binary data efficiently in Node.js. They serve as the backbone for many operations involving file I/O, networking, and streams. Understanding Buffers is key to mastering Node.js streams and dealing with data at a low level.

What does it mean to be allocated outside of the V8 engine?

V8 is the JavaScript engine used by Node.js. It is responsible for executing JavaScript code and managing memory allocation for JavaScript objects, such as strings, arrays, and objects. This memory is managed within a structure called the heap, which the V8 engine controls.

Buffers, on the other hand, are allocated in Node.js's C++ layer, which interfaces with the operating system directly. They are designed to handle binary data and are more efficient for certain operations, such as reading files or handling network protocols. To achieve this efficiency, Buffers allocate memory outside the V8 heap.

This means:

  1. Direct Memory Access: Buffers provide direct access to memory outside of V8's managed heap, allowing for faster and more efficient handling of raw binary data. This is especially useful for operations that require manipulation of large amounts of data, such as file I/O and networking.
  2. Fixed-Size Allocation: When a Buffer is created (as you will see in another section), it allocates a fixed-size block of memory. This block is not subject to the garbage collection process that manages the rest of the JavaScript objects in V8. As a result, Buffers can avoid the overhead associated with garbage collection, leading to better performance in memory-intensive operations.
  3. Native Code Interoperability: Allocating memory outside the V8 heap allows Node.js to interact more easily with native code (C/C++ libraries) and system-level resources, which often require access to raw binary data.

When you create a Buffer, the Node.js runtime allocates a block of memory from the system's memory pool. This is done using methods provided by the operating system, such as malloc in C. The allocated memory is then managed by Node.js but remains outside the control of the V8 engine.

How should I think of a Buffer?

To mentally visualize a Buffer, you can think of a water bucket outside of a house.

A house with a bucket outside. The house represents the V8 heap, while the bucket represents the Buffer in system memory.

A house with a bucket outside. The house represents the V8 heap, while the bucket represents the Buffer in system memory.

The house itself represents the V8 heap, where JavaScript objects like strings, arrays, and objects live.

The bucket outside the house represents the Buffer. It is a separate container for raw binary data that is not subject to the same rules and restrictions as the objects inside the house.

As for using the bucket (Buffer), you can think of a hose (data source) that can fill the bucket (Buffer) with water (data).

A hose filling a bucket with water. This represents the binary data held within a Buffer.

A hose filling a bucket with water. This represents the binary data held within a Buffer.

To start connecting the dots, let's start walking through some examples of what we can do with Buffers and round out our analogy.

Working with Buffers

To create a Buffer, you can use the Buffer class provided by Node.js. The buffer documentation recommends explicitly importing the Buffer class, although it is available in the global scope.

const { Buffer } = require("node:buffer"); // Create a Buffer of 8 bytes const buf1 = Buffer.alloc(8); // <Buffer 00 00 00 00 00 00 00 00> // Create a Buffer from a string const buf2 = Buffer.from("Hello, World!"); // <Buffer 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21> // Create a Buffer from an array of integers const buf3 = Buffer.from([1, 2, 3, 4, 5]); // <Buffer 01 02 03 04 05>

In the above example, if is buf1 that we can think of as our empty bucket without water, while buf2 and buf3 are our buckets that are already filled with water.

In order to fill buf1, we could also make use of the write method:

const buf1 = Buffer.alloc(8); // <Buffer 00 00 00 00 00 00 00 00> buf1.write("Hello!!!"); // <Buffer 48 65 6c 6c 6f 21 21 21>

Once a buffer is also created, we can replace "part of the water" directly:

buf1[7] = 0x65; // <Buffer 48 65 6c 6c 6f 21 21 65> buf1.toString(); // "Hello!e"

Buffer and V8 heap interaction

Note that every time we convert the Buffer back into a JavaScript object data type supported by V8, we are effectively bring it back into the house (V8 heap) which is managed by the V8 JavaScript engine.

This process of conversion has some important implications:

  1. Performance: Converting large Buffers to strings or other V8 types can be computationally expensive and may cause memory pressure on V8's heap.
  2. Memory usage: The converted data now exists in two places - the original Buffer (outside V8) and the new string or object (inside V8).
  3. Garbage collection: While the Buffer itself is managed outside of V8, any strings or objects created from it are subject to V8's garbage collection.
  4. Immutability: When you convert a Buffer to a string, you get an immutable JavaScript string. Any changes you make to this string will create a new string, not modify the original Buffer.

To demonstrate, consider the following:

const buf = Buffer.from("Hello, World!"); // buf is allocated outside V8's heap const str = buf.toString(); // str is a new string in V8's heap str[0] = "h"; // This doesn't modify str or buf console.log(str); // Still "Hello, World!" const str2 = buf.toString(); // Still "Hello, World!" but as a new string in V8's heap buf[0] = 0x68; // This modifies the Buffer directly const str3 = buf.toString(); // Now "hello, World!" as a new string in V8's heap

While looking at the above, I believe it is important to keep comparing what is happening to the analogy of the bucket outside the house.

Hexadecimal representation

For all of the code example above, I have added the hexadecimal representation of the Buffer in the comments.

For those unfamiliar with hexadecimal representation, each pair of characters in this representation corresponds to a single byte, represented in hexadecimal (base-16) notation.

In hexadecimal, each digit can be 0-9 or A-F, where A-F represent the decimal values 10-15 respectively.

For the byte values in my buf1 example, we have 48 65 6c 6c 6f 21 21 21 where each of these is a byte value in hex.

These hex values in this example correspond to ASCII characters:

  • 48 -> 'H'
  • 65 -> 'e'
  • 6c -> 'l'
  • 6c -> 'l'
  • 6f -> 'o'
  • 21 -> '!'
  • 21 -> '!'
  • 21 -> '!'

If we convert this buffer back into a string, it would return to again be "Hello!!!":

const { Buffer } = require("node:buffer"); // Create a Buffer of 8 bytes const buf1 = Buffer.alloc(8); // <Buffer 00 00 00 00 00 00 00 00> buf1.write("Hello!!!"); // <Buffer 48 65 6c 6c 6f 21 21 21> buf1.toString(); // "Hello!!!"

In fact, instead of using the string "Hello!!!" as an argument to write after allocating a buffer, we could even pass in hexadecimal values directly:

const buf1 = Buffer.from([0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21, 0x21, 0x21]); console.log(buf1.toString()); // Outputs: Hello!!! const buf2 = Buffer.from("48656c6c6f212121", "hex"); console.log(buf2.toString()); // Outputs: Hello!!! const buf3 = Buffer.alloc(8); [0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x21, 0x21, 0x21].forEach((byte, index) => { buf3.writeUInt8(byte, index); }); console.log(buf3.toString()); // Outputs: Hello!!! const buf4 = Buffer.alloc(8); buf4.write("\x48\x65\x6c\x6c\x6f\x21\x21\x21", "hex"); console.log(buf4.toString()); // Outputs: Hello!!!

Note that hexadecimal representation in JavaScript can be denoted by a leading 0x.

Common operations with Buffers

Methods for creating Buffers

Buffer.alloc(size)Create a new Buffer of specified size
Buffer.from(array)Create a Buffer from an array of bytes
Buffer.from(string, encoding)Create a Buffer from a string

Methods for reading and writing from Buffers

buf.toString(encoding, start, end)Convert Buffer to string
buf.write(string, offset, length, encoding)Write a string to the Buffer
buf.readUInt8(offset), buf.readUInt16LE(offset), etc.Read integer values
buf.writeUInt8(value, offset), buf.writeUInt16LE(value, offset), etc.Write integer values

Buffer methods for comparison and search

buf.equals(otherBuffer)Compare two Buffers
buf.indexOf(value[, byteOffset][, encoding])Find the index of a value in the Buffer
buf.includes(value[, byteOffset][, encoding])Check if Buffer includes a value

Buffer methods for slicing and copying

buf.slice([start[, end]])Create a new Buffer that references the same memory as the original
buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])Copy data between Buffers

Buffer methods for conversion

buf.toJSON()Convert Buffer to a JSON representation
Buffer.concat(list[, totalLength])Concatenate a list of Buffers

Common applications of Buffers

File operations

For example, reading from and writing to files, especially when dealing with binary data.

const fs = require("node:fs"); // Reading a file into a Buffer const buffer = fs.readFileSync("example.bin"); // <Buffer ... > // Writing a Buffer to a file fs.writeFileSync("output.bin", buffer);

Network communications

For example, handling raw data in network protocols.

const net = require("node:net"); const server = net.createServer((socket) => { socket.on("data", (buffer) => { console.log(buffer.toString()); }); });


This includes things like hashing, encryption, and decryption.

const crypto = require("node:crypto"); const data = Buffer.from("Hello, World!"); const hash = crypto.createHash("sha256").update(data).digest(); // <Buffer df fd 60 21 bb 2b d5 b0 af 67 62 90 80 9e c3 a5 31 91 dd 81 c7 f7 0a 4b 28 68 8a 36 21 82 98 6f>

Image processing

We can use Buffers to manipulate image data.

const sharp = require("sharp"); sharp("input.jpg") .resize(300, 200) .toBuffer((err, buffer) => { // buffer contains the processed image data });

Base64 encoding/decoding

Often used for data transfer and storage.

const original = Buffer.from("Hello, World!"); // <Buffer 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21> const encoded = original.toString("base64"); // 'SGVsbG8sIFdvcmxkIQ==' const decoded = Buffer.from(encoded, "base64"); // <Buffer 48 65 6c 6c 6f 2c 20 57 6f 72 6c 64 21> decoded.toString(); // "Hello, World!"

Data streaming

Efficiently processing large amounts of data. We will touch more on this throughout the series.

const fs = require("fs"); const readStream = fs.createReadStream("largefile.txt"); readStream.on("data", (chunk) => { // chunk is a Buffer console.log(chunk.length); });

The highs and lows of using Buffers

Here a some highs of using Buffers:

  • Efficient Binary Data Handling: Buffers are designed to handle raw binary data efficiently, making them ideal for file I/O, network communication, and other scenarios requiring direct manipulation of binary data.
  • Direct Memory Allocation: Buffers allocate memory outside the V8 heap, allowing for more efficient use of memory and avoiding the overhead of garbage collection.
  • High Performance: Direct access to memory and efficient handling of binary data result in high performance, especially for operations involving large amounts of data.
  • Interoperability with Native Code: Buffers facilitate interoperability with native code (C/C++ libraries) and system-level resources, making it easier to integrate with existing systems and perform low-level operations.
  • Flexibility in Data Encoding: Buffers support various data encodings (e.g., UTF-8, ASCII, Base64), making it easy to convert between different formats.

In contrast, here are some of the gotchas to look out for:

  • Fixed Size: Once a Buffer is created, its size cannot be changed. This means you need to allocate the correct amount of memory upfront, which can be difficult to estimate accurately.
  • Complexity: Using Buffers requires a decent understanding of binary data manipulation, memory management, and encoding/decoding, which can add complexity to the code.
  • Potential Security Risks: Improper handling of Buffers, such as misuse of Buffer.allocUnsafe, can lead to security vulnerabilities.
  • Less Readable Code: Code that deals with Buffers can be harder to read and understand compared to using higher-level abstractions, especially for developers not familiar with binary data manipulation.
  • Buffers do not work with objects directly: The type must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object. This means that you cannot pass an object directly to a Buffer (nor certain other types like booleans).


Buffers are a fundamental component in Node.js for handling raw binary data efficiently. By allocating memory outside the V8 heap, Buffers provide direct access to memory, enabling high performance for operations involving large data sets, such as file I/O and network communication. Understanding how Buffers work, including their fixed size and manual memory management requirements, is crucial for writing efficient Node.js applications.

In today's blog post, we've covered a the fundamental ideas behind Buffers in Node.js and we gave ourselves an analogy of a bucket outside a house to help us mentally visualize the concepts around Buffers.

While Buffers offer numerous advantages, including interoperability with native code and flexibility in data encoding, they also introduce complexity. Properly managing buffer allocation, avoiding common pitfalls, and ensuring memory is correctly handled are essential practices for developers working with Buffers.

By mastering Buffers, you'll be well-prepared to dive deeper into Node.js streams and handle data at a low level, paving the way for building robust and high-performance applications.

Resources and further reading

Disclaimer: This blog post used AI to generate the images used for the analogy.

Photo credit: nervum

Personal image

Dennis O'Keeffe

  • Melbourne, Australia

Hi, I am a professional Software Engineer. Formerly of Culture Amp, UsabilityHub, Present Company and NightGuru.
I am currently working on Visibuild.


Get fresh posts + news direct to your inbox.

No spam. We only send you relevant content.

Node.js Buffers Explained


Share this post