Buffer
A Buffer can be understood as a storage unit for binary code. The buffers are used to temporarily store the binary data before or after its transmission. Buffers are used to send and receive data smoothly between the sender and receiver.
Node.js buffer module
To handle the various binary data streams and file system operations, we can use the Buffer class from the buffer module in Node. The Buffer octets are used in Node to deal with TCP streams, to support buffer operations, to perform several file IO operations and to interact with the operating system itself because all these operations are performed upon binary data.
The Buffer class, which is a subclass of the Uint8Array class from JavaScript is a global class and contains several other important methods to support additional functionalities. It means Node.js APIs can accept plain Uint8Arrays wherever Buffers are supported as well. Buffer class can be accessed in any application without importing the buffer module as it is a global class.
An instance of the Buffer class can be used to store the raw data similar to an array of integers (from 0 to 255) and corresponds to a raw memory allocation outside the V8-heap. The size of the buffer is fixed and it cannot be changed once it is created.
Creating the buffers
var buf1 = Buffer.alloc(10);
//an
uninitialized Buffer of 10 octets filled with 0s
var buf2 = Buffer.alloc(10,1);
//an
uninitialized Buffer of 10 octets filled with 1s
var buf3 = Buffer.from([48, 49, 50,
51, 52]);
//creating
a Buffer from a given array
var buf4 = Buffer.from("Welcome to Node.js", "utf-8");
//creating
a Buffer from a given string and optionally encoding type
//encoding
types can be "ascii",
"utf8", "utf16le", "ucs2", "base64" or
"hex"
console.log(buf1.toString());
console.log(buf2.toString());
console.log(buf3.toString());
console.log(buf4.toString());/*
Output:
01234
Welcome to Node.js
*/
Important methods
alloc()
This method produces a Buffer instance of the provided length
allocUnsafe()
This method produces a non-zero-filled Buffer of the provided length
allocUnsafeSlow()
This method produces a non-zero-filled and non-pooled Buffer of the provided length.
byteLength()
This method returns the numbers of bytes in a provided object
compare()
This method is used to compare two Buffer instances
equals()
This method is used to compare two Buffer instances and this method will return true if a match is found, otherwise, false is returnedfill()
This method fills a Buffer instance with the provided values
concat()
This method is used to concatenate an array of Buffer instances into one Buffer instance
copy()
This method is used to copy the provided number of bytes of a Buffer instance
entries()
This method returns an iterator of "index" "byte" pairs of a Buffer instance
from()
This method produces a Buffer instance from an object (string/array/buffer)
includes()
This method tests if the Buffer instance contains the provided value. The method returns true if there is a match, otherwise false
indexOf()
This method tests if the Buffer instance contains the provided value. The method returns the first appearance, otherwise, it will return -1
isBuffer()
This method tests if an object is a Buffer instance or not
isEncoding()
This method tests if the Buffer instance supports the provided encoding or not
keys()
This method returns an array of keys in a Buffer instance
lastIndexOf()
This method tests if the Buffer instance contains the provided value. This method returns the first occurrence, starting from the end, otherwise, it will return -1
length
This method returns the length of a Buffer instance, in bytes
poolSize
This method sets or returns the number of bytes used for pooling
readDoubleBE()
This method reads a 64-bit double from a Buffer instance, returns the result in big-endian
readDoubleLE()
This method reads a 64 bit double from a Buffer instance, returns the result in little-endian
readFloatBE()
This method reads a 32-bit float from a Buffer instance, returns the result in big-endian
readFloatLE()
This method reads a 32-bit float from a Buffer instance, returns the result in little-endian
readInt8()
This method reads an 8-bit integer from a Buffer instance
readInt16BE()
This method reads a 16-bit integer from a Buffer instance, returns the result in big-endian
slice()
This method slices a Buffer instance into a new Buffer instance starting and ending at the provided positions
swap16()
This method swaps the byte-order of a 16-bit Buffer instance
swap32()
This method swaps the byte-order of a 32-bit Buffer instance
swap64()
This method swaps the byte-order of a 64-bit Buffer instance
toString()
This method returns a string version of a Buffer instance
toJSON()
This method returns a JSON version of a Buffer instance
values()
This method returns an array of values in a Buffer instance
write()
This method writes a provided string to a Buffer instance
writeDoubleBE()
This method writes the provided bytes, using big-endian, to a Buffer instance. The bytes must be 64 -bit double.
Simple operations on buffers
Reading a buffer
We can use to string method to read the buffer data. The syntax for the toString() method is,
buffer.toString([encoding][, start][, end])
buffer
= new Buffer.alloc(26);
for (var i = 0 ; i < 26 ; i++) {
buffer[i] = i + 97;
}
//toString
method
console.log(
buffer.toString('ascii'));
console.log(
buffer.toString('ascii',0,5));
console.log(
buffer.toString('utf8',0,5));
console.log(
buffer.toString(undefined,0,5));
Output:
abcdefghijklmnopqrstuvwxyz
abcde
abcde
abcde
*/
the default encoding is UTF-8.
Converting to JSON
buffer.toJSON() method is used to convert buffer into a JSON object.
var json = buffer.toJSON(buffer);
Output:
{
type:
'Buffer',
data: [
87, 101, 108, 99, 111, 109,
101, 32, 116, 111, 32,
78,
111, 100, 101, 46, 106, 115
]
}
*/Concatenate buffers
buffer.concat(list[, totalLength]) method is used to apply concatenation.
var buf2 = Buffer.from('A JavaScript framework');
var buf3 =
Buffer.concat([buf1,buf2]);
console.log("Resultant buffer: " + buf3.toString());
Output:
Resultant buffer: Welcome to Node.jsA JavaScript framework
*/Compare buffers
We can use bufA.compare(bufB) method to compare two buffers. This method returns a positive or negative value based upon which comes before or after.
var buf1 = Buffer.from('abc');
var buf2 = Buffer.from('abcd');
var res = buf1.compare(buf2);
if(res < 0) {
console.log(buf1 +" comes before " + buf2);
} else if(res === 0) {
console.log(buf1 +" is same as " + buf2);
} else {
console.log(buf1 +" comes after " + buf2);
}
console.log("Resultant buffer: " + buf3.toString());
Output:
abc comes before abcd
*/Copy Buffer
We can use copy method content of one buffer into other buffer.The syntax for this method is buf.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd])
var buf1 = Buffer.from('Node.js');
//copy
the buffer
var buf2 = Buffer.alloc(7);
buf1.copy(buf2);
console.log("Copied content:
" + buf2.toString());
Output:
Copied content: Node.js
*/Reference:https://nodejs.org/api/buffer.html