new buffer.Blob([sources[, options]])#

• sources<string[]> |<ArrayBuffer[]> |<TypedArray[]> |<DataView[]> |<Blob[]> Anarray of string,<ArrayBuffer>,<TypedArray>,<DataView>, or<Blob> objects,or any mix of such objects, that will be stored within theBlob.
• options<Object>
  • endings<string> One of either'transparent' or'native'. When setto'native', line endings in string source parts will be converted tothe platform native line-ending as specified byrequire('node:os').EOL.
  • type<string> The Blob content-type. The intent is fortype to conveythe MIME media type of the data, however no validation of the type formatis performed.

Creates a newBlob object containing a concatenation of the given sources.

<ArrayBuffer>,<TypedArray>,<DataView>, and<Buffer> sources are copied intothe 'Blob' and can therefore be safely modified after the 'Blob' is created.

String sources are encoded as UTF-8 byte sequences and copied into the Blob.Unmatched surrogate pairs within each string part will be replaced by UnicodeU+FFFD replacement characters.

blob.arrayBuffer()#

• Returns:<Promise>

Returns a promise that fulfills with an<ArrayBuffer> containing a copy oftheBlob data.

const blob =newBlob(['hello']);blob.bytes().then((bytes) => {console.log(bytes);// Outputs: Uint8Array(5) [ 104, 101, 108, 108, 111 ]});copy

blob.size#

The total size of theBlob in bytes.

blob.slice([start[, end[, type]]])#

• start<number> The starting index.
• end<number> The ending index.
• type<string> The content-type for the newBlob

Creates and returns a newBlob containing a subset of thisBlob objectsdata. The originalBlob is not altered.

blob.stream()#

• Returns:<ReadableStream>

Returns a newReadableStream that allows the content of theBlob to be read.

blob.text()#

• Returns:<Promise>

Returns a promise that fulfills with the contents of theBlob decoded as aUTF-8 string.

blob.type#

• Type:<string>

The content-type of theBlob.

Blob objects andMessageChannel#

Once a<Blob> object is created, it can be sent viaMessagePort to multipledestinations without transferring or immediately copying the data. The datacontained by theBlob is copied only when thearrayBuffer() ortext()methods are called.

import {Blob }from'node:buffer';import {setTimeoutas delay }from'node:timers/promises';const blob =newBlob(['hello there']);const mc1 =newMessageChannel();const mc2 =newMessageChannel();mc1.port1.onmessage =async ({ data }) => {console.log(await data.arrayBuffer());  mc1.port1.close();};mc2.port1.onmessage =async ({ data }) => {awaitdelay(1000);console.log(await data.arrayBuffer());  mc2.port1.close();};mc1.port2.postMessage(blob);mc2.port2.postMessage(blob);// The Blob is still usable after posting.blob.text().then(console.log);const {Blob } =require('node:buffer');const {setTimeout: delay } =require('node:timers/promises');const blob =newBlob(['hello there']);const mc1 =newMessageChannel();const mc2 =newMessageChannel();mc1.port1.onmessage =async ({ data }) => {console.log(await data.arrayBuffer());  mc1.port1.close();};mc2.port1.onmessage =async ({ data }) => {awaitdelay(1000);console.log(await data.arrayBuffer());  mc2.port1.close();};mc1.port2.postMessage(blob);mc2.port2.postMessage(blob);// The Blob is still usable after posting.blob.text().then(console.log);copy

Static method:Buffer.alloc(size[, fill[, encoding]])#

• size<integer> The desired length of the newBuffer.
• fill<string> |<Buffer> |<Uint8Array> |<integer> A value to pre-fill the newBufferwith.Default:0.
• encoding<string> Iffill is a string, this is its encoding.Default:'utf8'.
• Returns:<Buffer>

Allocates a newBuffer ofsize bytes. Iffill isundefined, theBuffer will be zero-filled.

import {Buffer }from'node:buffer';const buf =Buffer.alloc(5);console.log(buf);// Prints: <Buffer 00 00 00 00 00>const {Buffer } =require('node:buffer');const buf =Buffer.alloc(5);console.log(buf);// Prints: <Buffer 00 00 00 00 00>copy

Ifsize is larger thanbuffer.constants.MAX_LENGTH or smaller than 0,ERR_OUT_OF_RANGEis thrown.

Iffill is specified, the allocatedBuffer will be initialized by callingbuf.fill(fill).

import {Buffer }from'node:buffer';const buf =Buffer.alloc(5,'a');console.log(buf);// Prints: <Buffer 61 61 61 61 61>const {Buffer } =require('node:buffer');const buf =Buffer.alloc(5,'a');console.log(buf);// Prints: <Buffer 61 61 61 61 61>copy

If bothfill andencoding are specified, the allocatedBuffer will beinitialized by callingbuf.fill(fill, encoding).

import {Buffer }from'node:buffer';const buf =Buffer.alloc(11,'aGVsbG8gd29ybGQ=','base64');console.log(buf);// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>const {Buffer } =require('node:buffer');const buf =Buffer.alloc(11,'aGVsbG8gd29ybGQ=','base64');console.log(buf);// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>copy

CallingBuffer.alloc() can be measurably slower than the alternativeBuffer.allocUnsafe() but ensures that the newly createdBuffer instancecontents will never contain sensitive data from previous allocations, includingdata that might not have been allocated forBuffers.

ATypeError will be thrown ifsize is not a number.

Static method:Buffer.allocUnsafe(size)#

• size<integer> The desired length of the newBuffer.
• Returns:<Buffer>

Allocates a newBuffer ofsize bytes. Ifsize is larger thanbuffer.constants.MAX_LENGTH or smaller than 0,ERR_OUT_OF_RANGEis thrown.

The underlying memory forBuffer instances created in this way isnotinitialized. The contents of the newly createdBuffer are unknown andmay contain sensitive data. UseBuffer.alloc() instead to initializeBuffer instances with zeroes.

import {Buffer }from'node:buffer';const buf =Buffer.allocUnsafe(10);console.log(buf);// Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>buf.fill(0);console.log(buf);// Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>const {Buffer } =require('node:buffer');const buf =Buffer.allocUnsafe(10);console.log(buf);// Prints (contents may vary): <Buffer a0 8b 28 3f 01 00 00 00 50 32>buf.fill(0);console.log(buf);// Prints: <Buffer 00 00 00 00 00 00 00 00 00 00>copy

ATypeError will be thrown ifsize is not a number.

TheBuffer module pre-allocates an internalBuffer instance ofsizeBuffer.poolSize that is used as a pool for the fast allocation of newBuffer instances created usingBuffer.allocUnsafe(),Buffer.from(array),Buffer.from(string), andBuffer.concat() only whensize is less thanBuffer.poolSize >>> 1 (floor ofBuffer.poolSize divided by two).

Use of this pre-allocated internal memory pool is a key difference betweencallingBuffer.alloc(size, fill) vs.Buffer.allocUnsafe(size).fill(fill).Specifically,Buffer.alloc(size, fill) willnever use the internalBufferpool, whileBuffer.allocUnsafe(size).fill(fill)will use the internalBuffer pool ifsize is less than or equal to halfBuffer.poolSize. Thedifference is subtle but can be important when an application requires theadditional performance thatBuffer.allocUnsafe() provides.

Static method:Buffer.allocUnsafeSlow(size)#

• size<integer> The desired length of the newBuffer.
• Returns:<Buffer>

Allocates a newBuffer ofsize bytes. Ifsize is larger thanbuffer.constants.MAX_LENGTH or smaller than 0,ERR_OUT_OF_RANGEis thrown. A zero-lengthBuffer is created ifsize is 0.

The underlying memory forBuffer instances created in this way isnotinitialized. The contents of the newly createdBuffer are unknown andmay contain sensitive data. Usebuf.fill(0) to initializesuchBuffer instances with zeroes.

When usingBuffer.allocUnsafe() to allocate newBuffer instances,allocations less thanBuffer.poolSize >>> 1 (4KiB when default poolSize is used) are slicedfrom a single pre-allocatedBuffer. This allows applications to avoid thegarbage collection overhead of creating many individually allocatedBufferinstances. This approach improves both performance and memory usage byeliminating the need to track and clean up as many individualArrayBuffer objects.

However, in the case where a developer may need to retain a small chunk ofmemory from a pool for an indeterminate amount of time, it may be appropriateto create an un-pooledBuffer instance usingBuffer.allocUnsafeSlow() andthen copying out the relevant bits.

import {Buffer }from'node:buffer';// Need to keep around a few small chunks of memory.const store = [];socket.on('readable',() => {let data;while (null !== (data = readable.read())) {// Allocate for retained data.const sb =Buffer.allocUnsafeSlow(10);// Copy the data into the new allocation.    data.copy(sb,0,0,10);    store.push(sb);  }});const {Buffer } =require('node:buffer');// Need to keep around a few small chunks of memory.const store = [];socket.on('readable',() => {let data;while (null !== (data = readable.read())) {// Allocate for retained data.const sb =Buffer.allocUnsafeSlow(10);// Copy the data into the new allocation.    data.copy(sb,0,0,10);    store.push(sb);  }});copy

ATypeError will be thrown ifsize is not a number.

Static method:Buffer.byteLength(string[, encoding])#

• string<string> |<Buffer> |<TypedArray> |<DataView> |<ArrayBuffer> |<SharedArrayBuffer> Avalue to calculate the length of.
• encoding<string> Ifstring is a string, this is its encoding.Default:'utf8'.
• Returns:<integer> The number of bytes contained withinstring.

Returns the byte length of a string when encoded usingencoding.This is not the same asString.prototype.length, which does not accountfor the encoding that is used to convert the string into bytes.

For'base64','base64url', and'hex', this function assumes valid input.For strings that contain non-base64/hex-encoded data (e.g. whitespace), thereturn value might be greater than the length of aBuffer created from thestring.

import {Buffer }from'node:buffer';const str ='\u00bd + \u00bc = \u00be';console.log(`${str}:${str.length} characters, ` +`${Buffer.byteLength(str,'utf8')} bytes`);// Prints: ½ + ¼ = ¾: 9 characters, 12 bytesconst {Buffer } =require('node:buffer');const str ='\u00bd + \u00bc = \u00be';console.log(`${str}:${str.length} characters, ` +`${Buffer.byteLength(str,'utf8')} bytes`);// Prints: ½ + ¼ = ¾: 9 characters, 12 bytescopy

Whenstring is a<Buffer> |<DataView> |<TypedArray> |<ArrayBuffer> |<SharedArrayBuffer>,the byte length as reported by.byteLength is returned.

Static method:Buffer.compare(buf1, buf2)#

• buf1<Buffer> |<Uint8Array>
• buf2<Buffer> |<Uint8Array>
• Returns:<integer> Either-1,0, or1, depending on the result of thecomparison. Seebuf.compare() for details.

Comparesbuf1 tobuf2, typically for the purpose of sorting arrays ofBuffer instances. This is equivalent to callingbuf1.compare(buf2).

import {Buffer }from'node:buffer';const buf1 =Buffer.from('1234');const buf2 =Buffer.from('0123');const arr = [buf1, buf2];console.log(arr.sort(Buffer.compare));// Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]// (This result is equal to: [buf2, buf1].)const {Buffer } =require('node:buffer');const buf1 =Buffer.from('1234');const buf2 =Buffer.from('0123');const arr = [buf1, buf2];console.log(arr.sort(Buffer.compare));// Prints: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]// (This result is equal to: [buf2, buf1].)copy

Static method:Buffer.concat(list[, totalLength])#

• list<Buffer[]> |<Uint8Array[]> List ofBuffer or<Uint8Array>instances to concatenate.
• totalLength<integer> Total length of theBuffer instances inlistwhen concatenated.
• Returns:<Buffer>

Returns a newBuffer which is the result of concatenating all theBufferinstances in thelist together.

If the list has no items, or if thetotalLength is 0, then a new zero-lengthBuffer is returned.

IftotalLength is not provided, it is calculated from theBuffer instancesinlist by adding their lengths.

IftotalLength is provided, it is coerced to an unsigned integer. If thecombined length of theBuffers inlist exceedstotalLength, the result istruncated tototalLength. If the combined length of theBuffers inlist isless thantotalLength, the remaining space is filled with zeros.

import {Buffer }from'node:buffer';// Create a single `Buffer` from a list of three `Buffer` instances.const buf1 =Buffer.alloc(10);const buf2 =Buffer.alloc(14);const buf3 =Buffer.alloc(18);const totalLength = buf1.length + buf2.length + buf3.length;console.log(totalLength);// Prints: 42const bufA =Buffer.concat([buf1, buf2, buf3], totalLength);console.log(bufA);// Prints: <Buffer 00 00 00 00 ...>console.log(bufA.length);// Prints: 42const {Buffer } =require('node:buffer');// Create a single `Buffer` from a list of three `Buffer` instances.const buf1 =Buffer.alloc(10);const buf2 =Buffer.alloc(14);const buf3 =Buffer.alloc(18);const totalLength = buf1.length + buf2.length + buf3.length;console.log(totalLength);// Prints: 42const bufA =Buffer.concat([buf1, buf2, buf3], totalLength);console.log(bufA);// Prints: <Buffer 00 00 00 00 ...>console.log(bufA.length);// Prints: 42copy

Buffer.concat() may also use the internalBuffer pool likeBuffer.allocUnsafe() does.

Static method:Buffer.copyBytesFrom(view[, offset[, length]])#

• view<TypedArray> The<TypedArray> to copy.
• offset<integer> The starting offset withinview.Default:0.
• length<integer> The number of elements fromview to copy.Default:view.length - offset.
• Returns:<Buffer>

Copies the underlying memory ofview into a newBuffer.

const u16 =newUint16Array([0,0xffff]);const buf =Buffer.copyBytesFrom(u16,1,1);u16[1] =0;console.log(buf.length);// 2console.log(buf[0]);// 255console.log(buf[1]);// 255copy

Static method:Buffer.from(array)#

• array<integer[]>
• Returns:<Buffer>

Allocates a newBuffer using anarray of bytes in the range0 –255.Array entries outside that range will be truncated to fit into it.

import {Buffer }from'node:buffer';// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.const buf =Buffer.from([0x62,0x75,0x66,0x66,0x65,0x72]);const {Buffer } =require('node:buffer');// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.const buf =Buffer.from([0x62,0x75,0x66,0x66,0x65,0x72]);copy

Ifarray is anArray-like object (that is, one with alength property oftypenumber), it is treated as if it is an array, unless it is aBuffer oraUint8Array. This means all otherTypedArray variants get treated as anArray. To create aBuffer from the bytes backing aTypedArray, useBuffer.copyBytesFrom().

ATypeError will be thrown ifarray is not anArray or another typeappropriate forBuffer.from() variants.

Buffer.from(array) andBuffer.from(string) may also use the internalBuffer pool likeBuffer.allocUnsafe() does.

Static method:Buffer.from(arrayBuffer[, byteOffset[, length]])#

• arrayBuffer<ArrayBuffer> |<SharedArrayBuffer> An<ArrayBuffer>,<SharedArrayBuffer>, for example the.buffer property of a<TypedArray>.
• byteOffset<integer> Index of first byte to expose.Default:0.
• length<integer> Number of bytes to expose.Default:arrayBuffer.byteLength - byteOffset.
• Returns:<Buffer>

This creates a view of the<ArrayBuffer> without copying the underlyingmemory. For example, when passed a reference to the.buffer property of a<TypedArray> instance, the newly createdBuffer will share the sameallocated memory as the<TypedArray>'s underlyingArrayBuffer.

import {Buffer }from'node:buffer';const arr =newUint16Array(2);arr[0] =5000;arr[1] =4000;// Shares memory with `arr`.const buf =Buffer.from(arr.buffer);console.log(buf);// Prints: <Buffer 88 13 a0 0f>// Changing the original Uint16Array changes the Buffer also.arr[1] =6000;console.log(buf);// Prints: <Buffer 88 13 70 17>const {Buffer } =require('node:buffer');const arr =newUint16Array(2);arr[0] =5000;arr[1] =4000;// Shares memory with `arr`.const buf =Buffer.from(arr.buffer);console.log(buf);// Prints: <Buffer 88 13 a0 0f>// Changing the original Uint16Array changes the Buffer also.arr[1] =6000;console.log(buf);// Prints: <Buffer 88 13 70 17>copy

The optionalbyteOffset andlength arguments specify a memory range withinthearrayBuffer that will be shared by theBuffer.

import {Buffer }from'node:buffer';const ab =newArrayBuffer(10);const buf =Buffer.from(ab,0,2);console.log(buf.length);// Prints: 2const {Buffer } =require('node:buffer');const ab =newArrayBuffer(10);const buf =Buffer.from(ab,0,2);console.log(buf.length);// Prints: 2copy

ATypeError will be thrown ifarrayBuffer is not an<ArrayBuffer> or a<SharedArrayBuffer> or another type appropriate forBuffer.from()variants.

It is important to remember that a backingArrayBuffer can cover a rangeof memory that extends beyond the bounds of aTypedArray view. A newBuffer created using thebuffer property of aTypedArray may extendbeyond the range of theTypedArray:

import {Buffer }from'node:buffer';const arrA =Uint8Array.from([0x63,0x64,0x65,0x66]);// 4 elementsconst arrB =newUint8Array(arrA.buffer,1,2);// 2 elementsconsole.log(arrA.buffer === arrB.buffer);// trueconst buf =Buffer.from(arrB.buffer);console.log(buf);// Prints: <Buffer 63 64 65 66>const {Buffer } =require('node:buffer');const arrA =Uint8Array.from([0x63,0x64,0x65,0x66]);// 4 elementsconst arrB =newUint8Array(arrA.buffer,1,2);// 2 elementsconsole.log(arrA.buffer === arrB.buffer);// trueconst buf =Buffer.from(arrB.buffer);console.log(buf);// Prints: <Buffer 63 64 65 66>copy

Static method:Buffer.from(buffer)#

• buffer<Buffer> |<Uint8Array> An existingBuffer or<Uint8Array> fromwhich to copy data.
• Returns:<Buffer>

Copies the passedbuffer data onto a newBuffer instance.

import {Buffer }from'node:buffer';const buf1 =Buffer.from('buffer');const buf2 =Buffer.from(buf1);buf1[0] =0x61;console.log(buf1.toString());// Prints: aufferconsole.log(buf2.toString());// Prints: bufferconst {Buffer } =require('node:buffer');const buf1 =Buffer.from('buffer');const buf2 =Buffer.from(buf1);buf1[0] =0x61;console.log(buf1.toString());// Prints: aufferconsole.log(buf2.toString());// Prints: buffercopy

ATypeError will be thrown ifbuffer is not aBuffer or another typeappropriate forBuffer.from() variants.

Static method:Buffer.from(object[, offsetOrEncoding[, length]])#

• object<Object> An object supportingSymbol.toPrimitive orvalueOf().
• offsetOrEncoding<integer> |<string> A byte-offset or encoding.
• length<integer> A length.
• Returns:<Buffer>

For objects whosevalueOf() function returns a value not strictly equal toobject, returnsBuffer.from(object.valueOf(), offsetOrEncoding, length).

import {Buffer }from'node:buffer';const buf =Buffer.from(newString('this is a test'));// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>const {Buffer } =require('node:buffer');const buf =Buffer.from(newString('this is a test'));// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>copy

For objects that supportSymbol.toPrimitive, returnsBuffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding).

import {Buffer }from'node:buffer';classFoo {  [Symbol.toPrimitive]() {return'this is a test';  }}const buf =Buffer.from(newFoo(),'utf8');// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>const {Buffer } =require('node:buffer');classFoo {  [Symbol.toPrimitive]() {return'this is a test';  }}const buf =Buffer.from(newFoo(),'utf8');// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>copy

ATypeError will be thrown ifobject does not have the mentioned methods oris not of another type appropriate forBuffer.from() variants.

Static method:Buffer.from(string[, encoding])#

• string<string> A string to encode.
• encoding<string> The encoding ofstring.Default:'utf8'.
• Returns:<Buffer>

Creates a newBuffer containingstring. Theencoding parameter identifiesthe character encoding to be used when convertingstring into bytes.

import {Buffer }from'node:buffer';const buf1 =Buffer.from('this is a tést');const buf2 =Buffer.from('7468697320697320612074c3a97374','hex');console.log(buf1.toString());// Prints: this is a téstconsole.log(buf2.toString());// Prints: this is a téstconsole.log(buf1.toString('latin1'));// Prints: this is a téstconst {Buffer } =require('node:buffer');const buf1 =Buffer.from('this is a tést');const buf2 =Buffer.from('7468697320697320612074c3a97374','hex');console.log(buf1.toString());// Prints: this is a téstconsole.log(buf2.toString());// Prints: this is a téstconsole.log(buf1.toString('latin1'));// Prints: this is a téstcopy

ATypeError will be thrown ifstring is not a string or another typeappropriate forBuffer.from() variants.

Buffer.from(string) may also use the internalBuffer pool likeBuffer.allocUnsafe() does.

Static method:Buffer.isBuffer(obj)#

• obj<Object>
• Returns:<boolean>

Returnstrue ifobj is aBuffer,false otherwise.

import {Buffer }from'node:buffer';Buffer.isBuffer(Buffer.alloc(10));// trueBuffer.isBuffer(Buffer.from('foo'));// trueBuffer.isBuffer('a string');// falseBuffer.isBuffer([]);// falseBuffer.isBuffer(newUint8Array(1024));// falseconst {Buffer } =require('node:buffer');Buffer.isBuffer(Buffer.alloc(10));// trueBuffer.isBuffer(Buffer.from('foo'));// trueBuffer.isBuffer('a string');// falseBuffer.isBuffer([]);// falseBuffer.isBuffer(newUint8Array(1024));// falsecopy

Static method:Buffer.isEncoding(encoding)#

• encoding<string> A character encoding name to check.
• Returns:<boolean>

Returnstrue ifencoding is the name of a supported character encoding,orfalse otherwise.

import {Buffer }from'node:buffer';console.log(Buffer.isEncoding('utf8'));// Prints: trueconsole.log(Buffer.isEncoding('hex'));// Prints: trueconsole.log(Buffer.isEncoding('utf/8'));// Prints: falseconsole.log(Buffer.isEncoding(''));// Prints: falseconst {Buffer } =require('node:buffer');console.log(Buffer.isEncoding('utf8'));// Prints: trueconsole.log(Buffer.isEncoding('hex'));// Prints: trueconsole.log(Buffer.isEncoding('utf/8'));// Prints: falseconsole.log(Buffer.isEncoding(''));// Prints: falsecopy

Class property:Buffer.poolSize#

• <integer>Default:8192

This is the size (in bytes) of pre-allocated internalBuffer instances usedfor pooling. This value may be modified.

buf[index]#

• index<integer>

The index operator[index] can be used to get and set the octet at positionindex inbuf. The values refer to individual bytes, so the legal valuerange is between0x00 and0xFF (hex) or0 and255 (decimal).

This operator is inherited fromUint8Array, so its behavior on out-of-boundsaccess is the same asUint8Array. In other words,buf[index] returnsundefined whenindex is negative or greater or equal tobuf.length, andbuf[index] = value does not modify the buffer ifindex is negative or>= buf.length.

import {Buffer }from'node:buffer';// Copy an ASCII string into a `Buffer` one byte at a time.// (This only works for ASCII-only strings. In general, one should use// `Buffer.from()` to perform this conversion.)const str ='Node.js';const buf =Buffer.allocUnsafe(str.length);for (let i =0; i < str.length; i++) {  buf[i] = str.charCodeAt(i);}console.log(buf.toString('utf8'));// Prints: Node.jsconst {Buffer } =require('node:buffer');// Copy an ASCII string into a `Buffer` one byte at a time.// (This only works for ASCII-only strings. In general, one should use// `Buffer.from()` to perform this conversion.)const str ='Node.js';const buf =Buffer.allocUnsafe(str.length);for (let i =0; i < str.length; i++) {  buf[i] = str.charCodeAt(i);}console.log(buf.toString('utf8'));// Prints: Node.jscopy

buf.buffer#

• <ArrayBuffer> The underlyingArrayBuffer object based on which thisBufferobject is created.

ThisArrayBuffer is not guaranteed to correspond exactly to the originalBuffer. See the notes onbuf.byteOffset for details.

import {Buffer }from'node:buffer';const arrayBuffer =newArrayBuffer(16);const buffer =Buffer.from(arrayBuffer);console.log(buffer.buffer === arrayBuffer);// Prints: trueconst {Buffer } =require('node:buffer');const arrayBuffer =newArrayBuffer(16);const buffer =Buffer.from(arrayBuffer);console.log(buffer.buffer === arrayBuffer);// Prints: truecopy

buf.byteOffset#

• <integer> ThebyteOffset of theBuffer's underlyingArrayBuffer object.

When settingbyteOffset inBuffer.from(ArrayBuffer, byteOffset, length),or sometimes when allocating aBuffer smaller thanBuffer.poolSize, thebuffer does not start from a zero offset on the underlyingArrayBuffer.

This can cause problems when accessing the underlyingArrayBuffer directlyusingbuf.buffer, as other parts of theArrayBuffer may be unrelatedto theBuffer object itself.

A common issue when creating aTypedArray object that shares its memory withaBuffer is that in this case one needs to specify thebyteOffset correctly:

import {Buffer }from'node:buffer';// Create a buffer smaller than `Buffer.poolSize`.const nodeBuffer =Buffer.from([0,1,2,3,4,5,6,7,8,9]);// When casting the Node.js Buffer to an Int8Array, use the byteOffset// to refer only to the part of `nodeBuffer.buffer` that contains the memory// for `nodeBuffer`.newInt8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);const {Buffer } =require('node:buffer');// Create a buffer smaller than `Buffer.poolSize`.const nodeBuffer =Buffer.from([0,1,2,3,4,5,6,7,8,9]);// When casting the Node.js Buffer to an Int8Array, use the byteOffset// to refer only to the part of `nodeBuffer.buffer` that contains the memory// for `nodeBuffer`.newInt8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);copy

buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])#

• target<Buffer> |<Uint8Array> ABuffer or<Uint8Array> with which tocomparebuf.
• targetStart<integer> The offset withintarget at which to begincomparison.Default:0.
• targetEnd<integer> The offset withintarget at which to end comparison(not inclusive).Default:target.length.
• sourceStart<integer> The offset withinbuf at which to begin comparison.Default:0.
• sourceEnd<integer> The offset withinbuf at which to end comparison(not inclusive).Default:buf.length.
• Returns:<integer>

Comparesbuf withtarget and returns a number indicating whetherbufcomes before, after, or is the same astarget in sort order.Comparison is based on the actual sequence of bytes in eachBuffer.

• 0 is returned iftarget is the same asbuf
• 1 is returned iftarget should comebeforebuf when sorted.
• -1 is returned iftarget should comeafterbuf when sorted.

import {Buffer }from'node:buffer';const buf1 =Buffer.from('ABC');const buf2 =Buffer.from('BCD');const buf3 =Buffer.from('ABCD');console.log(buf1.compare(buf1));// Prints: 0console.log(buf1.compare(buf2));// Prints: -1console.log(buf1.compare(buf3));// Prints: -1console.log(buf2.compare(buf1));// Prints: 1console.log(buf2.compare(buf3));// Prints: 1console.log([buf1, buf2, buf3].sort(Buffer.compare));// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]// (This result is equal to: [buf1, buf3, buf2].)const {Buffer } =require('node:buffer');const buf1 =Buffer.from('ABC');const buf2 =Buffer.from('BCD');const buf3 =Buffer.from('ABCD');console.log(buf1.compare(buf1));// Prints: 0console.log(buf1.compare(buf2));// Prints: -1console.log(buf1.compare(buf3));// Prints: -1console.log(buf2.compare(buf1));// Prints: 1console.log(buf2.compare(buf3));// Prints: 1console.log([buf1, buf2, buf3].sort(Buffer.compare));// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]// (This result is equal to: [buf1, buf3, buf2].)copy

The optionaltargetStart,targetEnd,sourceStart, andsourceEndarguments can be used to limit the comparison to specific ranges withintargetandbuf respectively.

import {Buffer }from'node:buffer';const buf1 =Buffer.from([1,2,3,4,5,6,7,8,9]);const buf2 =Buffer.from([5,6,7,8,9,1,2,3,4]);console.log(buf1.compare(buf2,5,9,0,4));// Prints: 0console.log(buf1.compare(buf2,0,6,4));// Prints: -1console.log(buf1.compare(buf2,5,6,5));// Prints: 1const {Buffer } =require('node:buffer');const buf1 =Buffer.from([1,2,3,4,5,6,7,8,9]);const buf2 =Buffer.from([5,6,7,8,9,1,2,3,4]);console.log(buf1.compare(buf2,5,9,0,4));// Prints: 0console.log(buf1.compare(buf2,0,6,4));// Prints: -1console.log(buf1.compare(buf2,5,6,5));// Prints: 1copy

ERR_OUT_OF_RANGE is thrown iftargetStart < 0,sourceStart < 0,targetEnd > target.byteLength, orsourceEnd > source.byteLength.

buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])#

• target<Buffer> |<Uint8Array> ABuffer or<Uint8Array> to copy into.
• targetStart<integer> The offset withintarget at which to beginwriting.Default:0.
• sourceStart<integer> The offset withinbuf from which to begin copying.Default:0.
• sourceEnd<integer> The offset withinbuf at which to stop copying (notinclusive).Default:buf.length.
• Returns:<integer> The number of bytes copied.

Copies data from a region ofbuf to a region intarget, even if thetargetmemory region overlaps withbuf.

TypedArray.prototype.set() performs the same operation, and is availablefor all TypedArrays, including Node.jsBuffers, although it takesdifferent function arguments.

import {Buffer }from'node:buffer';// Create two `Buffer` instances.const buf1 =Buffer.allocUnsafe(26);const buf2 =Buffer.allocUnsafe(26).fill('!');for (let i =0; i <26; i++) {// 97 is the decimal ASCII value for 'a'.  buf1[i] = i +97;}// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.buf1.copy(buf2,8,16,20);// This is equivalent to:// buf2.set(buf1.subarray(16, 20), 8);console.log(buf2.toString('ascii',0,25));// Prints: !!!!!!!!qrst!!!!!!!!!!!!!const {Buffer } =require('node:buffer');// Create two `Buffer` instances.const buf1 =Buffer.allocUnsafe(26);const buf2 =Buffer.allocUnsafe(26).fill('!');for (let i =0; i <26; i++) {// 97 is the decimal ASCII value for 'a'.  buf1[i] = i +97;}// Copy `buf1` bytes 16 through 19 into `buf2` starting at byte 8 of `buf2`.buf1.copy(buf2,8,16,20);// This is equivalent to:// buf2.set(buf1.subarray(16, 20), 8);console.log(buf2.toString('ascii',0,25));// Prints: !!!!!!!!qrst!!!!!!!!!!!!!copy

import {Buffer }from'node:buffer';// Create a `Buffer` and copy data from one region to an overlapping region// within the same `Buffer`.const buf =Buffer.allocUnsafe(26);for (let i =0; i <26; i++) {// 97 is the decimal ASCII value for 'a'.  buf[i] = i +97;}buf.copy(buf,0,4,10);console.log(buf.toString());// Prints: efghijghijklmnopqrstuvwxyzconst {Buffer } =require('node:buffer');// Create a `Buffer` and copy data from one region to an overlapping region// within the same `Buffer`.const buf =Buffer.allocUnsafe(26);for (let i =0; i <26; i++) {// 97 is the decimal ASCII value for 'a'.  buf[i] = i +97;}buf.copy(buf,0,4,10);console.log(buf.toString());// Prints: efghijghijklmnopqrstuvwxyzcopy

buf.entries()#

• Returns:<Iterator>

Creates and returns aniterator of[index, byte] pairs from the contentsofbuf.

import {Buffer }from'node:buffer';// Log the entire contents of a `Buffer`.const buf =Buffer.from('buffer');for (const pairof buf.entries()) {console.log(pair);}// Prints://   [0, 98]//   [1, 117]//   [2, 102]//   [3, 102]//   [4, 101]//   [5, 114]const {Buffer } =require('node:buffer');// Log the entire contents of a `Buffer`.const buf =Buffer.from('buffer');for (const pairof buf.entries()) {console.log(pair);}// Prints://   [0, 98]//   [1, 117]//   [2, 102]//   [3, 102]//   [4, 101]//   [5, 114]copy

buf.equals(otherBuffer)#

• otherBuffer<Buffer> |<Uint8Array> ABuffer or<Uint8Array> with which tocomparebuf.
• Returns:<boolean>

Returnstrue if bothbuf andotherBuffer have exactly the same bytes,false otherwise. Equivalent tobuf.compare(otherBuffer) === 0.

import {Buffer }from'node:buffer';const buf1 =Buffer.from('ABC');const buf2 =Buffer.from('414243','hex');const buf3 =Buffer.from('ABCD');console.log(buf1.equals(buf2));// Prints: trueconsole.log(buf1.equals(buf3));// Prints: falseconst {Buffer } =require('node:buffer');const buf1 =Buffer.from('ABC');const buf2 =Buffer.from('414243','hex');const buf3 =Buffer.from('ABCD');console.log(buf1.equals(buf2));// Prints: trueconsole.log(buf1.equals(buf3));// Prints: falsecopy

buf.fill(value[, offset[, end]][, encoding])#

• value<string> |<Buffer> |<Uint8Array> |<integer> The value with which to fillbuf.Empty value (string, Uint8Array, Buffer) is coerced to0.
• offset<integer> Number of bytes to skip before starting to fillbuf.Default:0.
• end<integer> Where to stop fillingbuf (not inclusive).Default:buf.length.
• encoding<string> The encoding forvalue ifvalue is a string.Default:'utf8'.
• Returns:<Buffer> A reference tobuf.

Fillsbuf with the specifiedvalue. If theoffset andend are not given,the entirebuf will be filled:

import {Buffer }from'node:buffer';// Fill a `Buffer` with the ASCII character 'h'.const b =Buffer.allocUnsafe(50).fill('h');console.log(b.toString());// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh// Fill a buffer with empty stringconst c =Buffer.allocUnsafe(5).fill('');console.log(c.fill(''));// Prints: <Buffer 00 00 00 00 00>const {Buffer } =require('node:buffer');// Fill a `Buffer` with the ASCII character 'h'.const b =Buffer.allocUnsafe(50).fill('h');console.log(b.toString());// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh// Fill a buffer with empty stringconst c =Buffer.allocUnsafe(5).fill('');console.log(c.fill(''));// Prints: <Buffer 00 00 00 00 00>copy

value is coerced to auint32 value if it is not a string,Buffer, orinteger. If the resulting integer is greater than255 (decimal),buf will befilled withvalue & 255.

If the final write of afill() operation falls on a multi-byte character,then only the bytes of that character that fit intobuf are written:

import {Buffer }from'node:buffer';// Fill a `Buffer` with character that takes up two bytes in UTF-8.console.log(Buffer.allocUnsafe(5).fill('\u0222'));// Prints: <Buffer c8 a2 c8 a2 c8>const {Buffer } =require('node:buffer');// Fill a `Buffer` with character that takes up two bytes in UTF-8.console.log(Buffer.allocUnsafe(5).fill('\u0222'));// Prints: <Buffer c8 a2 c8 a2 c8>copy

Ifvalue contains invalid characters, it is truncated; if no validfill data remains, an exception is thrown:

import {Buffer }from'node:buffer';const buf =Buffer.allocUnsafe(5);console.log(buf.fill('a'));// Prints: <Buffer 61 61 61 61 61>console.log(buf.fill('aazz','hex'));// Prints: <Buffer aa aa aa aa aa>console.log(buf.fill('zz','hex'));// Throws an exception.const {Buffer } =require('node:buffer');const buf =Buffer.allocUnsafe(5);console.log(buf.fill('a'));// Prints: <Buffer 61 61 61 61 61>console.log(buf.fill('aazz','hex'));// Prints: <Buffer aa aa aa aa aa>console.log(buf.fill('zz','hex'));// Throws an exception.copy

buf.includes(value[, byteOffset][, encoding])#

• value<string> |<Buffer> |<Uint8Array> |<integer> What to search for.
• byteOffset<integer> Where to begin searching inbuf. If negative, thenoffset is calculated from the end ofbuf.Default:0.
• encoding<string> Ifvalue is a string, this is its encoding.Default:'utf8'.
• Returns:<boolean>true ifvalue was found inbuf,false otherwise.

Equivalent tobuf.indexOf() !== -1.

import {Buffer }from'node:buffer';const buf =Buffer.from('this is a buffer');console.log(buf.includes('this'));// Prints: trueconsole.log(buf.includes('is'));// Prints: trueconsole.log(buf.includes(Buffer.from('a buffer')));// Prints: trueconsole.log(buf.includes(97));// Prints: true (97 is the decimal ASCII value for 'a')console.log(buf.includes(Buffer.from('a buffer example')));// Prints: falseconsole.log(buf.includes(Buffer.from('a buffer example').slice(0,8)));// Prints: trueconsole.log(buf.includes('this',4));// Prints: falseconst {Buffer } =require('node:buffer');const buf =Buffer.from('this is a buffer');console.log(buf.includes('this'));// Prints: trueconsole.log(buf.includes('is'));// Prints: trueconsole.log(buf.includes(Buffer.from('a buffer')));// Prints: trueconsole.log(buf.includes(97));// Prints: true (97 is the decimal ASCII value for 'a')console.log(buf.includes(Buffer.from('a buffer example')));// Prints: falseconsole.log(buf.includes(Buffer.from('a buffer example').slice(0,8)));// Prints: trueconsole.log(buf.includes('this',4));// Prints: falsecopy

buf.indexOf(value[, byteOffset][, encoding])#

• value<string> |<Buffer> |<Uint8Array> |<integer> What to search for.
• byteOffset<integer> Where to begin searching inbuf. If negative, thenoffset is calculated from the end ofbuf.Default:0.
• encoding<string> Ifvalue is a string, this is the encoding used todetermine the binary representation of the string that will be searched for inbuf.Default:'utf8'.
• Returns:<integer> The index of the first occurrence ofvalue inbuf, or-1 ifbuf does not containvalue.

Ifvalue is:

• a string,value is interpreted according to the character encoding inencoding.
• aBuffer or<Uint8Array>,value will be used in its entirety.To compare a partialBuffer, usebuf.subarray.
• a number,value will be interpreted as an unsigned 8-bit integervalue between0 and255.

import {Buffer }from'node:buffer';const buf =Buffer.from('this is a buffer');console.log(buf.indexOf('this'));// Prints: 0console.log(buf.indexOf('is'));// Prints: 2console.log(buf.indexOf(Buffer.from('a buffer')));// Prints: 8console.log(buf.indexOf(97));// Prints: 8 (97 is the decimal ASCII value for 'a')console.log(buf.indexOf(Buffer.from('a buffer example')));// Prints: -1console.log(buf.indexOf(Buffer.from('a buffer example').slice(0,8)));// Prints: 8const utf16Buffer =Buffer.from('\u039a\u0391\u03a3\u03a3\u0395','utf16le');console.log(utf16Buffer.indexOf('\u03a3',0,'utf16le'));// Prints: 4console.log(utf16Buffer.indexOf('\u03a3', -4,'utf16le'));// Prints: 6const {Buffer } =require('node:buffer');const buf =Buffer.from('this is a buffer');console.log(buf.indexOf('this'));// Prints: 0console.log(buf.indexOf('is'));// Prints: 2console.log(buf.indexOf(Buffer.from('a buffer')));// Prints: 8console.log(buf.indexOf(97));// Prints: 8 (97 is the decimal ASCII value for 'a')console.log(buf.indexOf(Buffer.from('a buffer example')));// Prints: -1console.log(buf.indexOf(Buffer.from('a buffer example').slice(0,8)));// Prints: 8const utf16Buffer =Buffer.from('\u039a\u0391\u03a3\u03a3\u0395','utf16le');console.log(utf16Buffer.indexOf('\u03a3',0,'utf16le'));// Prints: 4console.log(utf16Buffer.indexOf('\u03a3', -4,'utf16le'));// Prints: 6copy

Ifvalue is not a string, number, orBuffer, this method will throw aTypeError. Ifvalue is a number, it will be coerced to a valid byte value,an integer between 0 and 255.

IfbyteOffset is not a number, it will be coerced to a number. If the resultof coercion isNaN or0, then the entire buffer will be searched. Thisbehavior matchesString.prototype.indexOf().

import {Buffer }from'node:buffer';const b =Buffer.from('abcdef');// Passing a value that's a number, but not a valid byte.// Prints: 2, equivalent to searching for 99 or 'c'.console.log(b.indexOf(99.9));console.log(b.indexOf(256 +99));// Passing a byteOffset that coerces to NaN or 0.// Prints: 1, searching the whole buffer.console.log(b.indexOf('b',undefined));console.log(b.indexOf('b', {}));console.log(b.indexOf('b',null));console.log(b.indexOf('b', []));const {Buffer } =require('node:buffer');const b =Buffer.from('abcdef');// Passing a value that's a number, but not a valid byte.// Prints: 2, equivalent to searching for 99 or 'c'.console.log(b.indexOf(99.9));console.log(b.indexOf(256 +99));// Passing a byteOffset that coerces to NaN or 0.// Prints: 1, searching the whole buffer.console.log(b.indexOf('b',undefined));console.log(b.indexOf('b', {}));console.log(b.indexOf('b',null));console.log(b.indexOf('b', []));copy

Ifvalue is an empty string or emptyBuffer andbyteOffset is lessthanbuf.length,byteOffset will be returned. Ifvalue is empty andbyteOffset is at leastbuf.length,buf.length will be returned.

buf.keys()#

• Returns:<Iterator>

Creates and returns aniterator ofbuf keys (indexes).

import {Buffer }from'node:buffer';const buf =Buffer.from('buffer');for (const keyof buf.keys()) {console.log(key);}// Prints://   0//   1//   2//   3//   4//   5const {Buffer } =require('node:buffer');const buf =Buffer.from('buffer');for (const keyof buf.keys()) {console.log(key);}// Prints://   0//   1//   2//   3//   4//   5copy

buf.lastIndexOf(value[, byteOffset][, encoding])#

• value<string> |<Buffer> |<Uint8Array> |<integer> What to search for.
• byteOffset<integer> Where to begin searching inbuf. If negative, thenoffset is calculated from the end ofbuf.Default:buf.length - 1.
• encoding<string> Ifvalue is a string, this is the encoding used todetermine the binary representation of the string that will be searched for inbuf.Default:'utf8'.
• Returns:<integer> The index of the last occurrence ofvalue inbuf, or-1 ifbuf does not containvalue.

Identical tobuf.indexOf(), except the last occurrence ofvalue is foundrather than the first occurrence.

import {Buffer }from'node:buffer';const buf =Buffer.from('this buffer is a buffer');console.log(buf.lastIndexOf('this'));// Prints: 0console.log(buf.lastIndexOf('buffer'));// Prints: 17console.log(buf.lastIndexOf(Buffer.from('buffer')));// Prints: 17console.log(buf.lastIndexOf(97));// Prints: 15 (97 is the decimal ASCII value for 'a')console.log(buf.lastIndexOf(Buffer.from('yolo')));// Prints: -1console.log(buf.lastIndexOf('buffer',5));// Prints: 5console.log(buf.lastIndexOf('buffer',4));// Prints: -1const utf16Buffer =Buffer.from('\u039a\u0391\u03a3\u03a3\u0395','utf16le');console.log(utf16Buffer.lastIndexOf('\u03a3',undefined,'utf16le'));// Prints: 6console.log(utf16Buffer.lastIndexOf('\u03a3', -5,'utf16le'));// Prints: 4const {Buffer } =require('node:buffer');const buf =Buffer.from('this buffer is a buffer');console.log(buf.lastIndexOf('this'));// Prints: 0console.log(buf.lastIndexOf('buffer'));// Prints: 17console.log(buf.lastIndexOf(Buffer.from('buffer')));// Prints: 17console.log(buf.lastIndexOf(97));// Prints: 15 (97 is the decimal ASCII value for 'a')console.log(buf.lastIndexOf(Buffer.from('yolo')));// Prints: -1console.log(buf.lastIndexOf('buffer',5));// Prints: 5console.log(buf.lastIndexOf('buffer',4));// Prints: -1const utf16Buffer =Buffer.from('\u039a\u0391\u03a3\u03a3\u0395','utf16le');console.log(utf16Buffer.lastIndexOf('\u03a3',undefined,'utf16le'));// Prints: 6console.log(utf16Buffer.lastIndexOf('\u03a3', -5,'utf16le'));// Prints: 4copy

Ifvalue is not a string, number, orBuffer, this method will throw aTypeError. Ifvalue is a number, it will be coerced to a valid byte value,an integer between 0 and 255.

IfbyteOffset is not a number, it will be coerced to a number. Any argumentsthat coerce toNaN, like{} orundefined, will search the whole buffer.This behavior matchesString.prototype.lastIndexOf().

import {Buffer }from'node:buffer';const b =Buffer.from('abcdef');// Passing a value that's a number, but not a valid byte.// Prints: 2, equivalent to searching for 99 or 'c'.console.log(b.lastIndexOf(99.9));console.log(b.lastIndexOf(256 +99));// Passing a byteOffset that coerces to NaN.// Prints: 1, searching the whole buffer.console.log(b.lastIndexOf('b',undefined));console.log(b.lastIndexOf('b', {}));// Passing a byteOffset that coerces to 0.// Prints: -1, equivalent to passing 0.console.log(b.lastIndexOf('b',null));console.log(b.lastIndexOf('b', []));const {Buffer } =require('node:buffer');const b =Buffer.from('abcdef');// Passing a value that's a number, but not a valid byte.// Prints: 2, equivalent to searching for 99 or 'c'.console.log(b.lastIndexOf(99.9));console.log(b.lastIndexOf(256 +99));// Passing a byteOffset that coerces to NaN.// Prints: 1, searching the whole buffer.console.log(b.lastIndexOf('b',undefined));console.log(b.lastIndexOf('b', {}));// Passing a byteOffset that coerces to 0.// Prints: -1, equivalent to passing 0.console.log(b.lastIndexOf('b',null));console.log(b.lastIndexOf('b', []));copy

Ifvalue is an empty string or emptyBuffer,byteOffset will be returned.

buf.length#

• <integer>

Returns the number of bytes inbuf.

import {Buffer }from'node:buffer';// Create a `Buffer` and write a shorter string to it using UTF-8.const buf =Buffer.alloc(1234);console.log(buf.length);// Prints: 1234buf.write('some string',0,'utf8');console.log(buf.length);// Prints: 1234const {Buffer } =require('node:buffer');// Create a `Buffer` and write a shorter string to it using UTF-8.const buf =Buffer.alloc(1234);console.log(buf.length);// Prints: 1234buf.write('some string',0,'utf8');console.log(buf.length);// Prints: 1234copy

buf.parent#

Thebuf.parent property is a deprecated alias forbuf.buffer.

buf.readBigInt64BE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy:0 <= offset <= buf.length - 8.Default:0.
• Returns:<bigint>

Reads a signed, big-endian 64-bit integer frombuf at the specifiedoffset.

Integers read from aBuffer are interpreted as two's complement signedvalues.

buf.readBigInt64LE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy:0 <= offset <= buf.length - 8.Default:0.
• Returns:<bigint>

Reads a signed, little-endian 64-bit integer frombuf at the specifiedoffset.

Integers read from aBuffer are interpreted as two's complement signedvalues.

buf.readBigUInt64BE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy:0 <= offset <= buf.length - 8.Default:0.
• Returns:<bigint>

Reads an unsigned, big-endian 64-bit integer frombuf at the specifiedoffset.

This function is also available under thereadBigUint64BE alias.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff]);console.log(buf.readBigUInt64BE(0));// Prints: 4294967295nconst {Buffer } =require('node:buffer');const buf =Buffer.from([0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff]);console.log(buf.readBigUInt64BE(0));// Prints: 4294967295ncopy

buf.readBigUInt64LE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy:0 <= offset <= buf.length - 8.Default:0.
• Returns:<bigint>

Reads an unsigned, little-endian 64-bit integer frombuf at the specifiedoffset.

This function is also available under thereadBigUint64LE alias.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff]);console.log(buf.readBigUInt64LE(0));// Prints: 18446744069414584320nconst {Buffer } =require('node:buffer');const buf =Buffer.from([0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff]);console.log(buf.readBigUInt64LE(0));// Prints: 18446744069414584320ncopy

buf.readDoubleBE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 8.Default:0.
• Returns:<number>

Reads a 64-bit, big-endian double frombuf at the specifiedoffset.

import {Buffer }from'node:buffer';const buf =Buffer.from([1,2,3,4,5,6,7,8]);console.log(buf.readDoubleBE(0));// Prints: 8.20788039913184e-304const {Buffer } =require('node:buffer');const buf =Buffer.from([1,2,3,4,5,6,7,8]);console.log(buf.readDoubleBE(0));// Prints: 8.20788039913184e-304copy

buf.readDoubleLE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 8.Default:0.
• Returns:<number>

Reads a 64-bit, little-endian double frombuf at the specifiedoffset.

import {Buffer }from'node:buffer';const buf =Buffer.from([1,2,3,4,5,6,7,8]);console.log(buf.readDoubleLE(0));// Prints: 5.447603722011605e-270console.log(buf.readDoubleLE(1));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([1,2,3,4,5,6,7,8]);console.log(buf.readDoubleLE(0));// Prints: 5.447603722011605e-270console.log(buf.readDoubleLE(1));// Throws ERR_OUT_OF_RANGE.copy

buf.readFloatBE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 4.Default:0.
• Returns:<number>

Reads a 32-bit, big-endian float frombuf at the specifiedoffset.

import {Buffer }from'node:buffer';const buf =Buffer.from([1,2,3,4]);console.log(buf.readFloatBE(0));// Prints: 2.387939260590663e-38const {Buffer } =require('node:buffer');const buf =Buffer.from([1,2,3,4]);console.log(buf.readFloatBE(0));// Prints: 2.387939260590663e-38copy

buf.readFloatLE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 4.Default:0.
• Returns:<number>

Reads a 32-bit, little-endian float frombuf at the specifiedoffset.

import {Buffer }from'node:buffer';const buf =Buffer.from([1,2,3,4]);console.log(buf.readFloatLE(0));// Prints: 1.539989614439558e-36console.log(buf.readFloatLE(1));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([1,2,3,4]);console.log(buf.readFloatLE(0));// Prints: 1.539989614439558e-36console.log(buf.readFloatLE(1));// Throws ERR_OUT_OF_RANGE.copy

buf.readInt8([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 1.Default:0.
• Returns:<integer>

Reads a signed 8-bit integer frombuf at the specifiedoffset.

Integers read from aBuffer are interpreted as two's complement signed values.

import {Buffer }from'node:buffer';const buf =Buffer.from([-1,5]);console.log(buf.readInt8(0));// Prints: -1console.log(buf.readInt8(1));// Prints: 5console.log(buf.readInt8(2));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([-1,5]);console.log(buf.readInt8(0));// Prints: -1console.log(buf.readInt8(1));// Prints: 5console.log(buf.readInt8(2));// Throws ERR_OUT_OF_RANGE.copy

buf.readInt16BE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 2.Default:0.
• Returns:<integer>

Reads a signed, big-endian 16-bit integer frombuf at the specifiedoffset.

Integers read from aBuffer are interpreted as two's complement signed values.

import {Buffer }from'node:buffer';const buf =Buffer.from([0,5]);console.log(buf.readInt16BE(0));// Prints: 5const {Buffer } =require('node:buffer');const buf =Buffer.from([0,5]);console.log(buf.readInt16BE(0));// Prints: 5copy

buf.readInt16LE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 2.Default:0.
• Returns:<integer>

Reads a signed, little-endian 16-bit integer frombuf at the specifiedoffset.

Integers read from aBuffer are interpreted as two's complement signed values.

import {Buffer }from'node:buffer';const buf =Buffer.from([0,5]);console.log(buf.readInt16LE(0));// Prints: 1280console.log(buf.readInt16LE(1));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([0,5]);console.log(buf.readInt16LE(0));// Prints: 1280console.log(buf.readInt16LE(1));// Throws ERR_OUT_OF_RANGE.copy

buf.readInt32BE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 4.Default:0.
• Returns:<integer>

Reads a signed, big-endian 32-bit integer frombuf at the specifiedoffset.

Integers read from aBuffer are interpreted as two's complement signed values.

import {Buffer }from'node:buffer';const buf =Buffer.from([0,0,0,5]);console.log(buf.readInt32BE(0));// Prints: 5const {Buffer } =require('node:buffer');const buf =Buffer.from([0,0,0,5]);console.log(buf.readInt32BE(0));// Prints: 5copy

buf.readInt32LE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 4.Default:0.
• Returns:<integer>

Reads a signed, little-endian 32-bit integer frombuf at the specifiedoffset.

Integers read from aBuffer are interpreted as two's complement signed values.

import {Buffer }from'node:buffer';const buf =Buffer.from([0,0,0,5]);console.log(buf.readInt32LE(0));// Prints: 83886080console.log(buf.readInt32LE(1));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([0,0,0,5]);console.log(buf.readInt32LE(0));// Prints: 83886080console.log(buf.readInt32LE(1));// Throws ERR_OUT_OF_RANGE.copy

buf.readIntBE(offset, byteLength)#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - byteLength.
• byteLength<integer> Number of bytes to read. Must satisfy0 < byteLength <= 6.
• Returns:<integer>

ReadsbyteLength number of bytes frombuf at the specifiedoffsetand interprets the result as a big-endian, two's complement signed valuesupporting up to 48 bits of accuracy.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x12,0x34,0x56,0x78,0x90,0xab]);console.log(buf.readIntBE(0,6).toString(16));// Prints: 1234567890abconsole.log(buf.readIntBE(1,6).toString(16));// Throws ERR_OUT_OF_RANGE.console.log(buf.readIntBE(1,0).toString(16));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([0x12,0x34,0x56,0x78,0x90,0xab]);console.log(buf.readIntBE(0,6).toString(16));// Prints: 1234567890abconsole.log(buf.readIntBE(1,6).toString(16));// Throws ERR_OUT_OF_RANGE.console.log(buf.readIntBE(1,0).toString(16));// Throws ERR_OUT_OF_RANGE.copy

buf.readIntLE(offset, byteLength)#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - byteLength.
• byteLength<integer> Number of bytes to read. Must satisfy0 < byteLength <= 6.
• Returns:<integer>

ReadsbyteLength number of bytes frombuf at the specifiedoffsetand interprets the result as a little-endian, two's complement signed valuesupporting up to 48 bits of accuracy.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x12,0x34,0x56,0x78,0x90,0xab]);console.log(buf.readIntLE(0,6).toString(16));// Prints: -546f87a9cbeeconst {Buffer } =require('node:buffer');const buf =Buffer.from([0x12,0x34,0x56,0x78,0x90,0xab]);console.log(buf.readIntLE(0,6).toString(16));// Prints: -546f87a9cbeecopy

buf.readUInt8([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 1.Default:0.
• Returns:<integer>

Reads an unsigned 8-bit integer frombuf at the specifiedoffset.

This function is also available under thereadUint8 alias.

import {Buffer }from'node:buffer';const buf =Buffer.from([1, -2]);console.log(buf.readUInt8(0));// Prints: 1console.log(buf.readUInt8(1));// Prints: 254console.log(buf.readUInt8(2));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([1, -2]);console.log(buf.readUInt8(0));// Prints: 1console.log(buf.readUInt8(1));// Prints: 254console.log(buf.readUInt8(2));// Throws ERR_OUT_OF_RANGE.copy

buf.readUInt16BE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 2.Default:0.
• Returns:<integer>

Reads an unsigned, big-endian 16-bit integer frombuf at the specifiedoffset.

This function is also available under thereadUint16BE alias.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x12,0x34,0x56]);console.log(buf.readUInt16BE(0).toString(16));// Prints: 1234console.log(buf.readUInt16BE(1).toString(16));// Prints: 3456const {Buffer } =require('node:buffer');const buf =Buffer.from([0x12,0x34,0x56]);console.log(buf.readUInt16BE(0).toString(16));// Prints: 1234console.log(buf.readUInt16BE(1).toString(16));// Prints: 3456copy

buf.readUInt16LE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 2.Default:0.
• Returns:<integer>

Reads an unsigned, little-endian 16-bit integer frombuf at the specifiedoffset.

This function is also available under thereadUint16LE alias.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x12,0x34,0x56]);console.log(buf.readUInt16LE(0).toString(16));// Prints: 3412console.log(buf.readUInt16LE(1).toString(16));// Prints: 5634console.log(buf.readUInt16LE(2).toString(16));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([0x12,0x34,0x56]);console.log(buf.readUInt16LE(0).toString(16));// Prints: 3412console.log(buf.readUInt16LE(1).toString(16));// Prints: 5634console.log(buf.readUInt16LE(2).toString(16));// Throws ERR_OUT_OF_RANGE.copy

buf.readUInt32BE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 4.Default:0.
• Returns:<integer>

Reads an unsigned, big-endian 32-bit integer frombuf at the specifiedoffset.

This function is also available under thereadUint32BE alias.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x12,0x34,0x56,0x78]);console.log(buf.readUInt32BE(0).toString(16));// Prints: 12345678const {Buffer } =require('node:buffer');const buf =Buffer.from([0x12,0x34,0x56,0x78]);console.log(buf.readUInt32BE(0).toString(16));// Prints: 12345678copy

buf.readUInt32LE([offset])#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - 4.Default:0.
• Returns:<integer>

Reads an unsigned, little-endian 32-bit integer frombuf at the specifiedoffset.

This function is also available under thereadUint32LE alias.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x12,0x34,0x56,0x78]);console.log(buf.readUInt32LE(0).toString(16));// Prints: 78563412console.log(buf.readUInt32LE(1).toString(16));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([0x12,0x34,0x56,0x78]);console.log(buf.readUInt32LE(0).toString(16));// Prints: 78563412console.log(buf.readUInt32LE(1).toString(16));// Throws ERR_OUT_OF_RANGE.copy

buf.readUIntBE(offset, byteLength)#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - byteLength.
• byteLength<integer> Number of bytes to read. Must satisfy0 < byteLength <= 6.
• Returns:<integer>

ReadsbyteLength number of bytes frombuf at the specifiedoffsetand interprets the result as an unsigned big-endian integer supportingup to 48 bits of accuracy.

This function is also available under thereadUintBE alias.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x12,0x34,0x56,0x78,0x90,0xab]);console.log(buf.readUIntBE(0,6).toString(16));// Prints: 1234567890abconsole.log(buf.readUIntBE(1,6).toString(16));// Throws ERR_OUT_OF_RANGE.const {Buffer } =require('node:buffer');const buf =Buffer.from([0x12,0x34,0x56,0x78,0x90,0xab]);console.log(buf.readUIntBE(0,6).toString(16));// Prints: 1234567890abconsole.log(buf.readUIntBE(1,6).toString(16));// Throws ERR_OUT_OF_RANGE.copy

buf.readUIntLE(offset, byteLength)#

• offset<integer> Number of bytes to skip before starting to read. Mustsatisfy0 <= offset <= buf.length - byteLength.
• byteLength<integer> Number of bytes to read. Must satisfy0 < byteLength <= 6.
• Returns:<integer>

ReadsbyteLength number of bytes frombuf at the specifiedoffsetand interprets the result as an unsigned, little-endian integer supportingup to 48 bits of accuracy.

This function is also available under thereadUintLE alias.

import {Buffer }from'node:buffer';const buf =Buffer.from([0x12,0x34,0x56,0x78,0x90,0xab]);console.log(buf.readUIntLE(0,6).toString(16));// Prints: ab9078563412const {Buffer } =require('node:buffer');const buf =Buffer.from([0x12,0x34,0x56,0x78,0x90,0xab]);console.log(buf.readUIntLE(0,6).toString(16));// Prints: ab9078563412copy

buf.subarray([start[, end]])#

• start<integer> Where the newBuffer will start.Default:0.
• end<integer> Where the newBuffer will end (not inclusive).Default:buf.length.
• Returns:<Buffer>

Returns a newBuffer that references the same memory as the original, butoffset and cropped by thestart andend indexes.

Specifyingend greater thanbuf.length will return the same result asthat ofend equal tobuf.length.

This method is inherited fromTypedArray.prototype.subarray().

Modifying the newBuffer slice will modify the memory in the originalBufferbecause the allocated memory of the two objects overlap.

import {Buffer }from'node:buffer';// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte// from the original `Buffer`.const buf1 =Buffer.allocUnsafe(26);for (let i =0; i <26; i++) {// 97 is the decimal ASCII value for 'a'.  buf1[i] = i +97;}const buf2 = buf1.subarray(0,3);console.log(buf2.toString('ascii',0, buf2.length));// Prints: abcbuf1[0] =33;console.log(buf2.toString('ascii',0, buf2.length));// Prints: !bcconst {Buffer } =require('node:buffer');// Create a `Buffer` with the ASCII alphabet, take a slice, and modify one byte// from the original `Buffer`.const buf1 =Buffer.allocUnsafe(26);for (let i =0; i <26; i++) {// 97 is the decimal ASCII value for 'a'.  buf1[i] = i +97;}const buf2 = buf1.subarray(0,3);console.log(buf2.toString('ascii',0, buf2.length));// Prints: abcbuf1[0] =33;console.log(buf2.toString('ascii',0, buf2.length));// Prints: !bccopy

Specifying negative indexes causes the slice to be generated relative to theend ofbuf rather than the beginning.

import {Buffer }from'node:buffer';const buf =Buffer.from('buffer');console.log(buf.subarray(-6, -1).toString());// Prints: buffe// (Equivalent to buf.subarray(0, 5).)console.log(buf.subarray(-6, -2).toString());// Prints: buff// (Equivalent to buf.subarray(0, 4).)console.log(buf.subarray(-5, -2).toString());// Prints: uff// (Equivalent to buf.subarray(1, 4).)const {Buffer } =require('node:buffer');const buf =Buffer.from('buffer');console.log(buf.subarray(-6, -1).toString());// Prints: buffe// (Equivalent to buf.subarray(0, 5).)console.log(buf.subarray(-6, -2).toString());// Prints: buff// (Equivalent to buf.subarray(0, 4).)console.log(buf.subarray(-5, -2).toString());// Prints: uff// (Equivalent to buf.subarray(1, 4).)copy

buf.slice([start[, end]])#

• start<integer> Where the newBuffer will start.Default:0.
• end<integer> Where the newBuffer will end (not inclusive).Default:buf.length.
• Returns:<Buffer>

Returns a newBuffer that references the same memory as the original, butoffset and cropped by thestart andend indexes.

This method is not compatible with theUint8Array.prototype.slice(),which is a superclass ofBuffer. To copy the slice, useUint8Array.prototype.slice().

import {Buffer }from'node:buffer';const buf =Buffer.from('buffer');const copiedBuf =Uint8Array.prototype.slice.call(buf);copiedBuf[0]++;console.log(copiedBuf.toString());// Prints: cufferconsole.log(buf.toString());// Prints: buffer// With buf.slice(), the original buffer is modified.const notReallyCopiedBuf = buf.slice();notReallyCopiedBuf[0]++;console.log(notReallyCopiedBuf.toString());// Prints: cufferconsole.log(buf.toString());// Also prints: cuffer (!)const {Buffer } =require('node:buffer');const buf =Buffer.from('buffer');const copiedBuf =Uint8Array.prototype.slice.call(buf);copiedBuf[0]++;console.log(copiedBuf.toString());// Prints: cufferconsole.log(buf.toString());// Prints: buffer// With buf.slice(), the original buffer is modified.const notReallyCopiedBuf = buf.slice();notReallyCopiedBuf[0]++;console.log(notReallyCopiedBuf.toString());// Prints: cufferconsole.log(buf.toString());// Also prints: cuffer (!)copy

buf.swap16()#

• Returns:<Buffer> A reference tobuf.

Interpretsbuf as an array of unsigned 16-bit integers and swaps thebyte orderin-place. ThrowsERR_INVALID_BUFFER_SIZE ifbuf.lengthis not a multiple of 2.

import {Buffer }from'node:buffer';const buf1 =Buffer.from([0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8]);console.log(buf1);// Prints: <Buffer 01 02 03 04 05 06 07 08>buf1.swap16();console.log(buf1);// Prints: <Buffer 02 01 04 03 06 05 08 07>const buf2 =Buffer.from([0x1,0x2,0x3]);buf2.swap16();// Throws ERR_INVALID_BUFFER_SIZE.const {Buffer } =require('node:buffer');const buf1 =Buffer.from([0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8]);console.log(buf1);// Prints: <Buffer 01 02 03 04 05 06 07 08>buf1.swap16();console.log(buf1);// Prints: <Buffer 02 01 04 03 06 05 08 07>const buf2 =Buffer.from([0x1,0x2,0x3]);buf2.swap16();// Throws ERR_INVALID_BUFFER_SIZE.copy

One convenient use ofbuf.swap16() is to perform a fast in-place conversionbetween UTF-16 little-endian and UTF-16 big-endian:

import {Buffer }from'node:buffer';const buf =Buffer.from('This is little-endian UTF-16','utf16le');buf.swap16();// Convert to big-endian UTF-16 text.const {Buffer } =require('node:buffer');const buf =Buffer.from('This is little-endian UTF-16','utf16le');buf.swap16();// Convert to big-endian UTF-16 text.copy

buf.swap32()#

• Returns:<Buffer> A reference tobuf.

Interpretsbuf as an array of unsigned 32-bit integers and swaps thebyte orderin-place. ThrowsERR_INVALID_BUFFER_SIZE ifbuf.lengthis not a multiple of 4.

import {Buffer }from'node:buffer';const buf1 =Buffer.from([0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8]);console.log(buf1);// Prints: <Buffer 01 02 03 04 05 06 07 08>buf1.swap32();console.log(buf1);// Prints: <Buffer 04 03 02 01 08 07 06 05>const buf2 =Buffer.from([0x1,0x2,0x3]);buf2.swap32();// Throws ERR_INVALID_BUFFER_SIZE.const {Buffer } =require('node:buffer');const buf1 =Buffer.from([0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8]);console.log(buf1);// Prints: <Buffer 01 02 03 04 05 06 07 08>buf1.swap32();console.log(buf1);// Prints: <Buffer 04 03 02 01 08 07 06 05>const buf2 =Buffer.from([0x1,0x2,0x3]);buf2.swap32();// Throws ERR_INVALID_BUFFER_SIZE.copy

buf.swap64()#

• Returns:<Buffer> A reference tobuf.

Interpretsbuf as an array of 64-bit numbers and swaps byte orderin-place.ThrowsERR_INVALID_BUFFER_SIZE ifbuf.length is not a multiple of 8.

import {Buffer }from'node:buffer';const buf1 =Buffer.from([0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8]);console.log(buf1);// Prints: <Buffer 01 02 03 04 05 06 07 08>buf1.swap64();console.log(buf1);// Prints: <Buffer 08 07 06 05 04 03 02 01>const buf2 =Buffer.from([0x1,0x2,0x3]);buf2.swap64();// Throws ERR_INVALID_BUFFER_SIZE.const {Buffer } =require('node:buffer');const buf1 =Buffer.from([0x1,0x2,0x3,0x4,0x5,0x6,0x7,0x8]);console.log(buf1);// Prints: <Buffer 01 02 03 04 05 06 07 08>buf1.swap64();console.log(buf1);// Prints: <Buffer 08 07 06 05 04 03 02 01>const buf2 =Buffer.from([0x1,0x2,0x3]);buf2.swap64();// Throws ERR_INVALID_BUFFER_SIZE.copy

buf.toJSON()#

• Returns:<Object>

Returns a JSON representation ofbuf.JSON.stringify() implicitly callsthis function when stringifying aBuffer instance.

Buffer.from() accepts objects in the format returned from this method.In particular,Buffer.from(buf.toJSON()) works likeBuffer.from(buf).

import {Buffer }from'node:buffer';const buf =Buffer.from([0x1,0x2,0x3,0x4,0x5]);const json =JSON.stringify(buf);console.log(json);// Prints: {"type":"Buffer","data":[1,2,3,4,5]}const copy =JSON.parse(json,(key, value) => {return value && value.type ==='Buffer' ?Buffer.from(value) :    value;});console.log(copy);// Prints: <Buffer 01 02 03 04 05>const {Buffer } =require('node:buffer');const buf =Buffer.from([0x1,0x2,0x3,0x4,0x5]);const json =JSON.stringify(buf);console.log(json);// Prints: {"type":"Buffer","data":[1,2,3,4,5]}const copy =JSON.parse(json,(key, value) => {return value && value.type ==='Buffer' ?Buffer.from(value) :    value;});console.log(copy);// Prints: <Buffer 01 02 03 04 05>copy

buf.toString([encoding[, start[, end]]])#

• encoding<string> The character encoding to use.Default:'utf8'.
• start<integer> The byte offset to start decoding at.Default:0.
• end<integer> The byte offset to stop decoding at (not inclusive).Default:buf.length.
• Returns:<string>

Decodesbuf to a string according to the specified character encoding inencoding.start andend may be passed to decode only a subset ofbuf.

Ifencoding is'utf8' and a byte sequence in the input is not valid UTF-8,then each invalid byte is replaced with the replacement characterU+FFFD.

The maximum length of a string instance (in UTF-16 code units) is availableasbuffer.constants.MAX_STRING_LENGTH.

import {Buffer }from'node:buffer';const buf1 =Buffer.allocUnsafe(26);for (let i =0; i <26; i++) {// 97 is the decimal ASCII value for 'a'.  buf1[i] = i +97;}console.log(buf1.toString('utf8'));// Prints: abcdefghijklmnopqrstuvwxyzconsole.log(buf1.toString('utf8',0,5));// Prints: abcdeconst buf2 =Buffer.from('tést');console.log(buf2.toString('hex'));// Prints: 74c3a97374console.log(buf2.toString('utf8',0,3));// Prints: téconsole.log(buf2.toString(undefined,0,3));// Prints: téconst {Buffer } =require('node:buffer');const buf1 =Buffer.allocUnsafe(26);for (let i =0; i <26; i++) {// 97 is the decimal ASCII value for 'a'.  buf1[i] = i +97;}console.log(buf1.toString('utf8'));// Prints: abcdefghijklmnopqrstuvwxyzconsole.log(buf1.toString('utf8',0,5));// Prints: abcdeconst buf2 =Buffer.from('tést');console.log(buf2.toString('hex'));// Prints: 74c3a97374console.log(buf2.toString('utf8',0,3));// Prints: téconsole.log(buf2.toString(undefined,0,3));// Prints: técopy

buf.values()#

• Returns:<Iterator>

Creates and returns aniterator forbuf values (bytes). This function iscalled automatically when aBuffer is used in afor..of statement.

import {Buffer }from'node:buffer';const buf =Buffer.from('buffer');for (const valueof buf.values()) {console.log(value);}// Prints://   98//   117//   102//   102//   101//   114for (const valueof buf) {console.log(value);}// Prints://   98//   117//   102//   102//   101//   114const {Buffer } =require('node:buffer');const buf =Buffer.from('buffer');for (const valueof buf.values()) {console.log(value);}// Prints://   98//   117//   102//   102//   101//   114for (const valueof buf) {console.log(value);}// Prints://   98//   117//   102//   102//   101//   114copy

buf.write(string[, offset[, length]][, encoding])#

• string<string> String to write tobuf.
• offset<integer> Number of bytes to skip before starting to writestring.Default:0.
• length<integer> Maximum number of bytes to write (written bytes will notexceedbuf.length - offset).Default:buf.length - offset.
• encoding<string> The character encoding ofstring.Default:'utf8'.
• Returns:<integer> Number of bytes written.

Writesstring tobuf atoffset according to the character encoding inencoding. Thelength parameter is the number of bytes to write. Ifbuf didnot contain enough space to fit the entire string, only part ofstring will bewritten. However, partially encoded characters will not be written.

import {Buffer }from'node:buffer';const buf =Buffer.alloc(256);const len = buf.write('\u00bd + \u00bc = \u00be',0);console.log(`${len} bytes:${buf.toString('utf8',0, len)}`);// Prints: 12 bytes: ½ + ¼ = ¾const buffer =Buffer.alloc(10);const length = buffer.write('abcd',8);console.log(`${length} bytes:${buffer.toString('utf8',8,10)}`);// Prints: 2 bytes : abconst {Buffer } =require('node:buffer');const buf =Buffer.alloc(256);const len = buf.write('\u00bd + \u00bc = \u00be',0);console.log(`${len} bytes:${buf.toString('utf8',0, len)}`);// Prints: 12 bytes: ½ + ¼ = ¾const buffer =Buffer.alloc(10);const length = buffer.write('abcd',8);console.log(`${length} bytes:${buffer.toString('utf8',8,10)}`);// Prints: 2 bytes : abcopy

buf.writeBigInt64BE(value[, offset])#

• value<bigint> Number to be written tobuf.
• offset<integer> Number of bytes to skip before starting to write. Mustsatisfy:0 <= offset <= buf.length - 8.Default:0.
• Returns:<integer>offset plus the number of bytes written.

Writesvalue tobuf at the specifiedoffset as big-endian.

value is interpreted and written as a two's complement signed integer.

import {Buffer }from'node:buffer';const buf =Buffer.allocUnsafe(8);buf.writeBigInt64BE(0x0102030405060708n,0);console.log(buf);// Prints: <Buffer 01 02 03 04 05 06 07 08>const {Buffer } =require('node:buffer');const buf =Buffer.allocUnsafe(8);buf.writeBigInt64BE(0x0102030405060708n,0);console.log(buf);// Prints: <Buffer 01 02 03 04 05 06 07 08>copy

buf.writeBigInt64LE(value[, offset])#

• value<bigint> Number to be written tobuf.
• offset<integer> Number of bytes to skip before starting to write. Mustsatisfy:0 <= offset <= buf.length - 8.Default:0.
• Returns:<integer>offset plus the number of bytes written.

Writesvalue tobuf at the specifiedoffset as little-endian.

value is interpreted and written as a two's complement signed integer.

import {Buffer }from'node:buffer';const buf =Buffer.allocUnsafe(8);buf.writeBigInt64LE(0x0102030405060708n,0);console.log(buf);// Prints: <Buffer 08 07 06 05 04 03 02 01>const {Buffer } =require('node:buffer');const buf =Buffer.allocUnsafe(8);buf.writeBigInt64LE(0x0102030405060708n,0);console.log(buf);// Prints: <Buffer 08 07 06 05 04 03 02 01>copy

buf.writeBigUInt64BE(value[, offset])#

• value<bigint> Number to be written tobuf.
• offset<integer> Number of bytes to skip before starting to write. Mustsatisfy:0 <= offset <= buf.length - 8.Default:0.
• Returns:<integer>offset plus the number of bytes written.

Writesvalue tobuf at the specifiedoffset as big-endian.

This function is also available under thewriteBigUint64BE alias.

import {Buffer }from'node:buffer';const buf =Buffer.allocUnsafe(8);buf.writeBigUInt64BE(0xdecafafecacefaden,0);console.log(buf);// Prints: <Buffer de ca fa fe ca ce fa de>const {Buffer } =require('node:buffer');const buf =Buffer.allocUnsafe(8);buf.writeBigUInt64BE(0xdecafafecacefaden,0);console.log(buf);// Prints: <Buffer de ca fa fe ca ce fa de>copy

buf.writeBigUInt64LE(value[, offset])#

• value<bigint> Number to be written tobuf.
• offset<integer> Number of bytes to skip before starting to write. Mustsatisfy:0 <= offset <= buf.length - 8.Default:0.
• Returns:<integer>offset plus the number of bytes written.

Writesvalue tobuf at the specifiedoffset as little-endian

import {Buffer }from'node:buffer';const buf =Buffer.allocUnsafe(8);buf.writeBigUInt64LE(0xdecafafecacefaden,0);console.log(buf);// Prints: <Buffer de fa ce ca fe fa ca de>const {Buffer } =require('node:buffer');const buf =Buffer.allocUnsafe(8);buf.writeBigUInt64LE(0xdecafafecacefaden,0);console.log(buf);// Prints: <Buffer de fa ce ca fe fa ca de>copy

This function is also available under thewriteBigUint64LE alias.

buf.writeDoubleBE(value[, offset])#

• value<number> Number to be written tobuf.
• offset<integer> Number of bytes to skip before starting to write. Mustsatisfy0 <= offset <= buf.length - 8.Default:0.
• Returns:<integer>offset plus the number of bytes written.

Writesvalue tobuf at the specifiedoffset as big-endian. Thevaluemust be a JavaScript number. Behavior is undefined whenvalue is anythingother than a JavaScript number.

import {Buffer }from'node:buffer';const buf =Buffer.allocUnsafe(8);buf.writeDoubleBE(123.456,0);console.log(buf);// Prints: <Buffer 40 5e dd 2f 1a 9f be 77>const {Buffer } =require('node:buffer');const buf =Buffer.allocUnsafe(8);buf.writeDoubleBE(123.456,0);console.log(buf);// Prints: <Buffer 40 5e dd 2f 1a 9f be 77>copy

buf.writeDoubleLE(value[, offset])#

• value<number> Number to be written tobuf.
• offset<integer> Number of bytes to skip before starting to write. Mustsatisfy0 <= offset <= buf.length - 8.Default:0.
• Returns:<integer>offset plus the number of bytes written.

Writesvalue tobuf at the specifiedoffset as little-endian. Thevaluemust be a JavaScript number. Behavior is undefined whenvalue is anythingother than a JavaScript number.

import {Buffer }from'node:buffer';const buf =Buffer.allocUnsafe(8);buf.writeDoubleLE(123.456,0);console.log(buf);// Prints: <Buffer 77 be 9f 1a 2f dd 5e 40>const {Buffer } =require('node:buffer');const buf =Buffer.allocUnsafe(8);buf.writeDoubleLE(123.456,0);console.log(buf);// Prints: <Buffer 77 be 9f 1a 2f dd 5e 40>copy

buf.writeFloatBE(value[, offset])#

• value<number> Number to be written tobuf.
• offset<integer> Number of bytes to skip before starting to write. Mustsatisfy0 <= offset <= buf.length - 4.Default:0.
• Returns:<integer>offset plus the number of bytes written.

Writesvalue tobuf at the specifiedoffset as big-endian. Behavior isundefined whenvalue is anything other than a JavaScript number.

import {Buffer }from'node:buffer';const buf =Buffer.allocUnsafe(4);buf.writeFloatBE(0xcafebabe,0);console.log(buf);// Prints: <Buffer 4f 4a fe bb>const {Buffer } =require('node:buffer');const buf =Buffer.allocUnsafe(4);buf.writeFloatBE(0xcafebabe,0);console.log(buf);// Prints: <Buffer 4f 4a fe bb>copy

buf.writeFloatLE(value[, offset])#