Menu
×
   ❮     
HTML CSS JAVASCRIPT SQL PYTHON JAVA PHP HOW TO W3.CSS C C++ C# BOOTSTRAP REACT MYSQL JQUERY EXCEL XML DJANGO NUMPY PANDAS NODEJS DSA TYPESCRIPT ANGULAR GIT POSTGRESQL MONGODB ASP AI R GO KOTLIN SASS VUE GEN AI SCIPY CYBERSECURITY DATA SCIENCE INTRO TO PROGRAMMING BASH RUST

Node.js Tutorial

Node HOME Node Intro Node Get Started Node JS Requirements Node.js vs Browser Node Cmd Line Node V8 Engine Node Architecture Node Event Loop

Asynchronous

Node Async Node Promises Node Async/Await Node Errors Handling

Module Basics

Node Modules Node ES Modules Node NPM Node package.json Node NPM Scripts Node Manage Dep Node Publish Packages

Core Modules

HTTP Module HTTPS Module File System (fs) Path Module OS Module URL Module Events Module Stream Module Buffer Module Crypto Module Timers Module DNS Module Assert Module Util Module Readline Module

JS & TS Features

Node ES6+ Node Process Node TypeScript Node Adv. TypeScript Node Lint & Formatting

Building Applications

Node Frameworks Express.js Middleware Concept REST API Design API Authentication Node.js with Frontend

Database Integration

MySQL Get Started MySQL Create Database MySQL Create Table MySQL Insert Into MySQL Select From MySQL Where MySQL Order By MySQL Delete MySQL Drop Table MySQL Update MySQL Limit MySQL Join
MongoDB Get Started MongoDB Create DB MongoDB Collection MongoDB Insert MongoDB Find MongoDB Query MongoDB Sort MongoDB Delete MongoDB Drop Collection MongoDB Update MongoDB Limit MongoDB Join

Advanced Communication

GraphQL Socket.IO WebSockets

Testing & Debugging

Node Adv. Debugging Node Testing Apps Node Test Frameworks Node Test Runner

Node.js Deployment

Node Env Variables Node Dev vs Prod Node CI/CD Node Security Node Deployment

Perfomance & Scaling

Node Logging Node Monitoring Node Performance Child Process Module Cluster Module Worker Threads

Node.js Advanced

Microservices Node WebAssembly HTTP2 Module Perf_hooks Module VM Module TLS/SSL Module Net Module Zlib Module Real-World Examples

Hardware & IoT

RasPi Get Started RasPi GPIO Introduction RasPi Blinking LED RasPi LED & Pushbutton RasPi Flowing LEDs RasPi WebSocket RasPi RGB LED WebSocket RasPi Components

Node.js Reference

Built-in Modules EventEmitter (events) Worker (cluster) Cipher (crypto) Decipher (crypto) DiffieHellman (crypto) ECDH (crypto) Hash (crypto) Hmac (crypto) Sign (crypto) Verify (crypto) Socket (dgram, net, tls) ReadStream (fs, stream) WriteStream (fs, stream) Server (http, https, net, tls) Agent (http, https) Request (http) Response (http) Message (http) Interface (readline)

Resources & Tools

Node.js Compiler Node.js Server Node.js Quiz Node.js Exercises Node.js Syllabus Node.js Study Plan Node.js Certificate

Node.js Buffer Module


What is the Buffer Module?

The Buffer module in Node.js is used to handle binary data.

Buffers are similar to arrays of integers but are fixed-length and correspond to raw memory allocations outside the V8 JavaScript engine.

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

Note: Since Node.js v6.0.0, the Buffer constructor is deprecated in favor of the new Buffer methods.

Using the constructor could lead to security vulnerabilities due to uninitialized memory.


Getting Started with Buffers

Buffers in Node.js are used to handle binary data directly.

They are similar to arrays of integers but are fixed in size and represent raw memory allocations outside the V8 heap.

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
Try it Yourself »

Creating Buffers

There are several ways to create buffers in Node.js, each with different performance and safety characteristics:

There are several ways to create buffers in Node.js:

1. Buffer.alloc()

Creates a new Buffer of the specified size, initialized with zeros.

This is the safest way to create a new buffer as it ensures no old data is present.

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

2. Buffer.allocUnsafe()

Creates a new Buffer of the specified size, but doesn't initialize the memory.

This is faster than Buffer.alloc() but may contain old or sensitive data.

Always fill the buffer before use if security is a concern.

// 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);
Run example »

Warning: Buffer.allocUnsafe() is faster than Buffer.alloc() but can expose sensitive data.

Only use it when you understand the security implications and plan to immediately fill the entire buffer.

3. Buffer.from()

Creates a new Buffer from various sources like strings, arrays, or ArrayBuffer. This is the most flexible way to create buffers from existing data.

// 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);
Run example »


Using Buffers

Writing to Buffers

You can write data to a buffer using various methods:

// 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());
Run example »

Reading from Buffers

You can read data from a buffer using various methods:

// 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]));
Run example »

Iterating Through Buffers

Buffers can be iterated like arrays:

// 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}`);
});
Run example »

Buffer Methods

Buffer.compare()

Compares two buffers and returns a number indicating whether the first one comes before, after, or is the same as the second one in sort order:

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));
Run example »

buffer.copy()

Copies data from one buffer to another:

// 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());
Run example »

buffer.slice()

Creates a new buffer that references the same memory as the original, but with offset and cropped to the given end:

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());
Run example »

Note: Since buffer.slice() creates a view of the same memory, modifying either the original buffer or the slice will affect the other.

buffer.toString()

Decodes a buffer to a string using a specified encoding:

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());
Run example »

buffer.equals()

Compares two buffers for content equality:

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);
Run example »

Working with Encodings

Buffers work with various encodings when converting between strings and binary data:

// 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);
Run example »

Supported encodings in Node.js include:

  • utf8: Multi-byte encoded Unicode characters (default)
  • ascii: ASCII characters only (7-bit)
  • latin1: Latin-1 encoding (ISO 8859-1)
  • base64: Base64 encoding
  • hex: Hexadecimal encoding
  • binary: Binary encoding (deprecated)
  • ucs2/utf16le: 2 or 4 bytes, little-endian encoded Unicode characters

Advanced Buffer Operations

Concatenating Buffers

You can combine multiple buffers into one using Buffer.concat():

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'
Run example »

Searching in Buffers

Buffers provide methods to search for values or sequences:

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
Run example »

Buffer and Streams

Buffers are commonly used with streams for efficient data processing:

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

Buffers are commonly used for file system operations:

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());
        // Output: Node.

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

Buffer Performance Considerations

  • Memory Usage: Buffers consume memory outside the JavaScript heap, which can be both an advantage (less garbage collection pressure) and a disadvantage (must be carefully managed)
  • Allocation: Buffer.allocUnsafe() is faster than Buffer.alloc() but comes with security considerations
  • String Conversion: Converting large buffers to strings or vice versa can be expensive
  • Pooling: For applications that frequently create small buffers, consider implementing a buffer pool to reduce allocation overhead
// Simple buffer pool implementation
class BufferPool {
  constructor(bufferSize = 1024, poolSize = 10) {
    this.bufferSize = bufferSize;
    this.pool = Array(poolSize).fill().map(() => Buffer.alloc(bufferSize));

    this.used = Array(poolSize).fill(false);
  }

  // Get a buffer from the pool
  get() {
    const index = this.used.indexOf(false);
    if (index === -1) {
       // Pool is full, create a new buffer
       console.log('Pool full, allocating new buffer');
       return Buffer.alloc(this.bufferSize);
    }
    this.used[index] = true;
    return this.pool[index];
  }

  // Return a buffer to the pool
  release(buffer) {
    const index = this.pool.indexOf(buffer);
    if (index !== -1) {
       // Zero the buffer for security
       buffer.fill(0);
       this.used[index] = false;
    }
  }
}

// Usage example
const pool = new BufferPool(10, 3); // 3 buffers of 10 bytes each

const buf1 = pool.get();
const buf2 = pool.get();
const buf3 = pool.get();
const buf4 = pool.get(); // This will allocate a new buffer

buf1.write('Hello');
console.log(buf1.toString()); // Hello

// Return buf1 to the pool
pool.release(buf1);

// Get another buffer (should reuse buf1)
const buf5 = pool.get();
console.log(buf5.toString()); // Should be empty (zeros)
Run example »

Buffer Security Considerations

Security Warning: Buffers can contain sensitive data from memory.

Always be cautious when handling buffers, especially when they might be exposed to users or logged.

Best Practices:

  • Avoid using Buffer.allocUnsafe() unless performance is critical and you immediately fill the buffer
  • Zero-fill buffers after use when they contained sensitive information
  • Be careful when sharing buffer instances or slices, as changes are reflected across all references
  • Validate buffer inputs when receiving binary data from external sources
// Example: Safely handling sensitive data
function processPassword(password) {
  // Create a buffer to hold the password
  const passwordBuffer = Buffer.from(password);

  // Process the password (e.g., hashing)
  const hashedPassword = hashPassword(passwordBuffer);

  // Zero out the original password buffer for security
  passwordBuffer.fill(0);

  return hashedPassword;
}

// Simple hashing function for demonstration
function hashPassword(buffer) {
  // In a real application, you would use a cryptographic hash function
  // This is a simplified example
  let hash = 0;
  for (let i = 0; i < buffer.length; i++) {
    hash = ((hash < 5) - hash) + buffer[i];
    hash |= 0; // Convert to 32-bit integer
  }
  return hash.toString(16);
}

// Usage
const password = 'secret123';
const hashedPassword = processPassword(password);
console.log('Hashed password:', hashedPassword);
Run example »

Summary

The Node.js Buffer class is an essential tool for working with binary data. Key points to remember:

  • Buffers provide a way to handle binary data in JavaScript
  • Use Buffer.alloc(), Buffer.from(), and Buffer.allocUnsafe() to create buffers
  • Buffers can be manipulated with methods like write(), toString(), slice(), and copy()
  • Buffers support various encodings including UTF-8, Base64, and Hex
  • Buffers are commonly used in file I/O, network operations, and binary data processing
  • Consider performance and security implications when working with buffers



×

Contact Sales

If you want to use W3Schools services as an educational institution, team or enterprise, send us an e-mail:
sales@w3schools.com

Report Error

If you want to report an error, or if you want to make a suggestion, send us an e-mail:
help@w3schools.com

W3Schools is optimized for learning and training. Examples might be simplified to improve reading and learning. Tutorials, references, and examples are constantly reviewed to avoid errors, but we cannot warrant full correctness of all content. While using W3Schools, you agree to have read and accepted our terms of use, cookie and privacy policy.

Copyright 1999-2025 by Refsnes Data. All Rights Reserved. W3Schools is Powered by W3.CSS.