buffers

What is buffers?

The 'buffers' npm package provides utilities for managing and manipulating binary data in Node.js. It is designed to simplify the handling of binary data by providing a buffer collection that automatically manages the memory allocation and data flow.

What are buffers's main functionalities?

Buffer Collection Creation

This feature allows the creation of a buffer collection where multiple buffers can be pushed into the collection and managed as a single entity. The example demonstrates pushing several buffers and then converting the entire collection to a string.

const Buffers = require('buffers');
const buf = Buffers();
buf.push(new Buffer('Hello'));
buf.push(new Buffer(' '));
buf.push(new Buffer('World'));
console.log(buf.toString()); // Outputs: 'Hello World'

Data Access and Manipulation

This feature demonstrates accessing individual bytes and slicing parts of the buffer collection. It shows how to access the first byte and how to slice the buffer to get a specific range of data.

const Buffers = require('buffers');
const buf = Buffers();
buf.push(new Buffer('Hello'));
buf.push(new Buffer(' World'));
console.log(buf.get(0)); // Outputs: 72 (ASCII code for 'H')
console.log(buf.slice(0, 5).toString()); // Outputs: 'Hello'

Buffer Length Calculation

This feature shows how to calculate the total length of all buffers in the collection. It is useful for understanding the total amount of data stored in the buffer collection.

const Buffers = require('buffers');
const buf = Buffers();
buf.push(new Buffer('Hello'));
buf.push(new Buffer(' World'));
console.log(buf.length); // Outputs: 11

Other packages similar to buffers

buffer

The 'buffer' package is a built-in Node.js module that also handles binary data. Unlike 'buffers', which is designed for managing collections of buffers, 'buffer' focuses on a single buffer instance. It provides more detailed control over each buffer but does not automatically handle multiple buffers as a single entity.

concat-stream

The 'concat-stream' package is used to concatenate buffer chunks from streams into a single buffer. It is similar to 'buffers' in that it deals with multiple buffers, but it is specifically tailored for stream handling and automatically concatenates all chunks into one buffer, which is different from manually managing buffer collections in 'buffers'.

README

buffers

Treat a collection of Buffers as a single contiguous partially mutable Buffer.

Where possible, operations execute without creating a new Buffer and copying everything over.

This is a cleaner more Buffery rehash of bufferlist.

example

slice

var Buffers = require('buffers');
var bufs = Buffers();
bufs.push(new Buffer([1,2,3]));
bufs.push(new Buffer([4,5,6,7]));
bufs.push(new Buffer([8,9,10]));

console.dir(bufs.slice(2,8))

output:

$ node examples/slice.js 
<Buffer 03 04 05 06 07 08>

splice

var Buffers = require('buffers');
var bufs = Buffers([
    new Buffer([1,2,3]),
    new Buffer([4,5,6,7]),
    new Buffer([8,9,10]),
]);

var removed = bufs.splice(2, 4);
console.dir({
    removed : removed.slice(),
    bufs : bufs.slice(),
});

output:

$ node examples/splice.js
{ removed: <Buffer 03 04 05 06>,
  bufs: <Buffer 01 02 07 08 09 0a> }

methods

Buffers(buffers)

Create a Buffers with an array of Buffers if specified, else [].

.push(buf1, buf2...)

Push buffers onto the end. Just like Array.prototype.push.

.unshift(buf1, buf2...)

Unshift buffers onto the head. Just like Array.prototype.unshift.

.slice(i, j)

Slice a range out of the buffer collection as if it were contiguous. Works just like the Array.prototype.slice version.

.splice(i, howMany, replacements)

Splice the buffer collection as if it were contiguous. Works just like Array.prototype.splice, even the replacement part!

.copy(dst, dstStart, start, end)

Copy the buffer collection as if it were contiguous to the dst Buffer with the specified bounds. Works just like Buffer.prototype.copy.

.get(i)

Get a single element at index i.

.set(i, x)

Set a single element's value at index i.

.indexOf(needle, offset)

Find a string or buffer needle inside the buffer collection. Returns the position of the search string or -1 if the search string was not found.

Provide an offset to skip that number of characters at the beginning of the search. This can be used to find additional matches.

This function will return the correct result even if the search string is spread out over multiple internal buffers.

.toBuffer()

Convert the buffer collection to a single buffer, equivalent with .slice(0, buffers.length);

.toString(encoding, start, end)

Decodes and returns a string from the buffer collection. Works just like Buffer.prototype.toString