Node.js v25.0.0 ドキュメンテーション

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

• sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> Blob内に格納される、string、<ArrayBuffer>、<TypedArray>、<DataView>、または<Blob>オブジェクトの配列、またはそれらのオブジェクトの任意の組み合わせ。
• options <Object>
  • endings <string> 'transparent'または'native'のいずれか。'native'に設定すると、文字列ソース部分の行末は、require('node:os').EOLで指定されたプラットフォームネイティブの行末に変換されます。
  • type <string> Blobのコンテントタイプ。typeはデータのMIMEメディアタイプを伝えることを意図していますが、タイプ形式の検証は行われません。

与えられたソースを連結したものを含む新しいBlobオブジェクトを作成します。

<ArrayBuffer>、<TypedArray>、<DataView>、および<Buffer>ソースは「Blob」にコピーされるため、「Blob」が作成された後でも安全に変更できます。

文字列ソースはUTF-8バイトシーケンスとしてエンコードされ、Blobにコピーされます。各文字列部分内の不一致のサロゲートペアは、Unicode U+FFFD置換文字に置き換えられます。

blob.arrayBuffer()#

• 戻り値: <Promise>

Blobデータのコピーを含む<ArrayBuffer>で解決されるPromiseを返します。

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

blob.size#

Blobの総サイズ（バイト単位）。

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

• start <number> 開始インデックス。
• end <number> 終了インデックス。
• type <string> 新しいBlobのコンテントタイプ。

このBlobオブジェクトのデータのサブセットを含む新しいBlobを作成して返します。元のBlobは変更されません。

blob.stream()#

• 戻り値: <ReadableStream>

Blobのコンテンツを読み取ることができる新しいReadableStreamを返します。

blob.text()#

• 戻り値: <Promise>

BlobのコンテンツをUTF-8文字列としてデコードしたもので解決されるPromiseを返します。

blob.type#

• 型: <string>

Blobのコンテントタイプ。

BlobオブジェクトとMessageChannel#

<Blob>オブジェクトが作成されると、データを転送したり即座にコピーしたりすることなく、MessagePort経由で複数の宛先に送信できます。Blobに含まれるデータは、arrayBuffer()またはtext()メソッドが呼び出されたときにのみコピーされます。

import { Blob } from 'node:buffer';
import { setTimeout as delay } from 'node:timers/promises';

const blob = new Blob(['hello there']);

const mc1 = new MessageChannel();
const mc2 = new MessageChannel();

mc1.port1.onmessage = async ({ data }) => {
  console.log(await data.arrayBuffer());
  mc1.port1.close();
};

mc2.port1.onmessage = async ({ data }) => {
  await delay(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 = new Blob(['hello there']);

const mc1 = new MessageChannel();
const mc2 = new MessageChannel();

mc1.port1.onmessage = async ({ data }) => {
  console.log(await data.arrayBuffer());
  mc1.port1.close();
};

mc2.port1.onmessage = async ({ data }) => {
  await delay(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

静的メソッド: Buffer.alloc(size[, fill[, encoding]])#

• size <integer> 新しいBufferの希望する長さ。
• fill <string> | <Buffer> | <Uint8Array> | <integer> 新しいBufferを事前に埋める値。デフォルト: 0。
• encoding <string> fillが文字列の場合、そのエンコーディングです。デフォルト: 'utf8'。
• 戻り値: <Buffer>

sizeバイトの新しいBufferを割り当てます。fillがundefinedの場合、Bufferはゼロで埋められます。

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

sizeがbuffer.constants.MAX_LENGTHより大きいか、0より小さい場合、ERR_OUT_OF_RANGEがスローされます。

fillが指定されている場合、割り当てられたBufferはbuf.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

fillとencodingの両方が指定されている場合、割り当てられたBufferはbuf.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

Buffer.alloc()の呼び出しは、代替のBuffer.allocUnsafe()よりも著しく遅くなる可能性がありますが、新しく作成されたBufferインスタンスの内容が、Buffer用に割り当てられていない可能性のあるデータを含む、以前の割り当てからの機密データを含まないことを保証します。

sizeが数値でない場合、TypeErrorがスローされます。

静的メソッド: Buffer.allocUnsafe(size)#

• size <integer> 新しいBufferの希望する長さ。
• 戻り値: <Buffer>

sizeバイトの新しいBufferを割り当てます。sizeがbuffer.constants.MAX_LENGTHより大きいか、0より小さい場合、ERR_OUT_OF_RANGEがスローされます。

この方法で作成されたBufferインスタンスの基礎となるメモリは*初期化されません*。新しく作成されたBufferの内容は不明であり、*機密データを含む可能性があります*。Bufferインスタンスをゼロで初期化するには、代わりにBuffer.alloc()を使用してください。

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

sizeが数値でない場合、TypeErrorがスローされます。

Bufferモジュールは、Buffer.poolSizeサイズの内部Bufferインスタンスを事前に割り当てます。これは、sizeがBuffer.poolSize >>> 1（Buffer.poolSizeを2で割った床値）より小さい場合にのみ、Buffer.allocUnsafe()、Buffer.from(array)、Buffer.from(string)、およびBuffer.concat()を使用して作成される新しいBufferインスタンスの高速割り当てのためのプールとして使用されます。

この事前に割り当てられた内部メモリプールの使用は、Buffer.alloc(size, fill)とBuffer.allocUnsafe(size).fill(fill)を呼び出すことの重要な違いです。具体的には、Buffer.alloc(size, fill)は内部Bufferプールを*決して*使用しませんが、Buffer.allocUnsafe(size).fill(fill)は、sizeがBuffer.poolSizeの半分以下の場合に内部Bufferプールを*使用します*。この違いは微妙ですが、アプリケーションがBuffer.allocUnsafe()が提供する追加のパフォーマンスを必要とする場合には重要になることがあります。

静的メソッド: Buffer.allocUnsafeSlow(size)#

• size <integer> 新しいBufferの希望する長さ。
• 戻り値: <Buffer>

sizeバイトの新しいBufferを割り当てます。sizeがbuffer.constants.MAX_LENGTHより大きいか、0より小さい場合、ERR_OUT_OF_RANGEがスローされます。sizeが0の場合、ゼロ長のBufferが作成されます。

この方法で作成されたBufferインスタンスの基礎となるメモリは*初期化されません*。新しく作成されたBufferの内容は不明であり、*機密データを含む可能性があります*。そのようなBufferインスタンスをゼロで初期化するには、buf.fill(0)を使用してください。

Buffer.allocUnsafe()を使用して新しいBufferインスタンスを割り当てる際、Buffer.poolSize >>> 1（デフォルトのpoolSizeが使用される場合は4KiB）未満の割り当ては、単一の事前に割り当てられたBufferからスライスされます。これにより、アプリケーションは多数の個別に割り当てられたBufferインスタンスを作成することによるガベージコレクションのオーバーヘッドを回避できます。このアプローチは、追跡およびクリーンアップする必要のある個別のArrayBufferオブジェクトの数を減らすことにより、パフォーマンスとメモリ使用量の両方を向上させます。

しかし、開発者が不確定な期間、プールからメモリの小さなチャンクを保持する必要がある場合、Buffer.allocUnsafeSlow()を使用してプールされていないBufferインスタンスを作成し、関連するビットをコピーアウトすることが適切な場合があります。

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

sizeが数値でない場合、TypeErrorがスローされます。

静的メソッド: Buffer.byteLength(string[, encoding])#

• string <string> | <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <SharedArrayBuffer> 長さを計算する値。
• encoding <string> stringが文字列の場合、そのエンコーディングです。デフォルト: 'utf8'。
• 戻り値: <integer> stringに含まれるバイト数。

encodingを使用してエンコードされた場合の文字列のバイト長を返します。これは、文字列をバイトに変換するために使用されるエンコーディングを考慮しないString.prototype.lengthとは異なります。

'base64'、'base64url'、および'hex'の場合、この関数は有効な入力を想定します。非base64/hexエンコードデータ（例：空白）を含む文字列の場合、戻り値は文字列から作成されたBufferの長さより大きい場合があります。

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

stringが<Buffer> | <DataView> | <TypedArray> | <ArrayBuffer> | <SharedArrayBuffer>の場合、.byteLengthによって報告されるバイト長が返されます。

静的メソッド: Buffer.compare(buf1, buf2)#

• buf1 <Buffer> | <Uint8Array>
• buf2 <Buffer> | <Uint8Array>
• 戻り値: <integer> 比較の結果に応じて、-1、0、または1のいずれか。詳細はbuf.compare()を参照してください。

buf1をbuf2と比較します。通常はBufferインスタンスの配列をソートする目的で使用されます。これはbuf1.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

静的メソッド: Buffer.concat(list[, totalLength])#

• list <Buffer[]> | <Uint8Array[]> 連結するBufferまたは<Uint8Array>インスタンスのリスト。
• totalLength <integer> 連結されたときのlist内のBufferインスタンスの合計長。
• 戻り値: <Buffer>

list内のすべてのBufferインスタンスを連結した結果である新しいBufferを返します。

リストに項目がない場合、またはtotalLengthが0の場合、新しいゼロ長のBufferが返されます。

totalLengthが提供されない場合、list内のBufferインスタンスから、それらの長さを加算して計算されます。

totalLengthが提供された場合、それは符号なし整数に強制変換されます。list内のBufferの合計長がtotalLengthを超える場合、結果はtotalLengthに切り捨てられます。list内のBufferの合計長がtotalLengthより短い場合、残りのスペースはゼロで埋められます。

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: 42

const 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: 42

const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);

console.log(bufA);
// Prints: <Buffer 00 00 00 00 ...>
console.log(bufA.length);
// Prints: 42copy

Buffer.concat()は、Buffer.allocUnsafe()のように内部のBufferプールを使用することもあります。

静的メソッド: Buffer.copyBytesFrom(view[, offset[, length]])#

• view <TypedArray> コピーする<TypedArray>。
• offset <integer> view内の開始オフセット。デフォルト: 0。
• length <integer> viewからコピーする要素の数。デフォルト: view.length - offset。
• 戻り値: <Buffer>

viewの基礎となるメモリを新しいBufferにコピーします。

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

静的メソッド: Buffer.from(array)#

• array <integer[]>
• 戻り値: <Buffer>

0から255の範囲のバイトのarrayを使用して新しいBufferを割り当てます。その範囲外の配列エントリは、それに収まるように切り捨てられます。

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

arrayがArrayライクなオブジェクト（つまり、number型のlengthプロパティを持つオブジェクト）である場合、それがBufferまたはUint8Arrayでない限り、配列として扱われます。これは、他のすべてのTypedArrayの亜種がArrayとして扱われることを意味します。TypedArrayをバックアップするバイトからBufferを作成するには、Buffer.copyBytesFrom()を使用してください。

arrayがArrayまたはBuffer.from()の他のバリアントに適した型でない場合、TypeErrorがスローされます。

Buffer.from(array)とBuffer.from(string)は、Buffer.allocUnsafe()のように内部のBufferプールを使用することもあります。

静的メソッド: Buffer.from(arrayBuffer[, byteOffset[, length]])#

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> <ArrayBuffer>、<SharedArrayBuffer>、例えば<TypedArray>の.bufferプロパティ。
• byteOffset <integer> 公開する最初のバイトのインデックス。デフォルト: 0。
• length <integer> 公開するバイト数。デフォルト: arrayBuffer.byteLength - byteOffset。
• 戻り値: <Buffer>

これは、基礎となるメモリをコピーすることなく、<ArrayBuffer>のビューを作成します。例えば、<TypedArray>インスタンスの.bufferプロパティへの参照を渡した場合、新しく作成されたBufferは、<TypedArray>の基礎となるArrayBufferと同じ割り当てられたメモリを共有します。

import { Buffer } from 'node:buffer';

const arr = new Uint16Array(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 = new Uint16Array(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

オプションのbyteOffsetとlength引数は、Bufferによって共有されるarrayBuffer内のメモリ範囲を指定します。

import { Buffer } from 'node:buffer';

const ab = new ArrayBuffer(10);
const buf = Buffer.from(ab, 0, 2);

console.log(buf.length);
// Prints: 2const { Buffer } = require('node:buffer');

const ab = new ArrayBuffer(10);
const buf = Buffer.from(ab, 0, 2);

console.log(buf.length);
// Prints: 2copy

arrayBufferが<ArrayBuffer>または<SharedArrayBuffer>、またはBuffer.from()の他のバリアントに適した型でない場合、TypeErrorがスローされます。

バッキングArrayBufferがTypedArrayビューの境界を超えてメモリの範囲をカバーできることを覚えておくことが重要です。TypedArrayのbufferプロパティを使用して作成された新しいBufferは、TypedArrayの範囲を超える可能性があります。

import { Buffer } from 'node:buffer';

const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]); // 4 elements
const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
console.log(arrA.buffer === arrB.buffer); // true

const 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 elements
const arrB = new Uint8Array(arrA.buffer, 1, 2); // 2 elements
console.log(arrA.buffer === arrB.buffer); // true

const buf = Buffer.from(arrB.buffer);
console.log(buf);
// Prints: <Buffer 63 64 65 66>copy

静的メソッド: Buffer.from(buffer)#

• buffer <Buffer> | <Uint8Array> データをコピーする元の既存のBufferまたは<Uint8Array>。
• 戻り値: <Buffer>

渡されたbufferのデータを新しいBufferインスタンスにコピーします。

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from('buffer');
const buf2 = Buffer.from(buf1);

buf1[0] = 0x61;

console.log(buf1.toString());
// Prints: auffer
console.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: auffer
console.log(buf2.toString());
// Prints: buffercopy

bufferがBufferまたはBuffer.from()の他のバリアントに適した型でない場合、TypeErrorがスローされます。

静的メソッド: Buffer.from(object[, offsetOrEncoding[, length]])#

• object <Object> Symbol.toPrimitiveまたはvalueOf()をサポートするオブジェクト。
• offsetOrEncoding <integer> | <string> バイトオフセットまたはエンコーディング。
• length <integer> 長さ。
• 戻り値: <Buffer>

valueOf()関数がobjectと厳密に等しくない値を返すオブジェクトの場合、Buffer.from(object.valueOf(), offsetOrEncoding, length)を返します。

import { Buffer } from 'node:buffer';

const buf = Buffer.from(new String('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(new String('this is a test'));
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>copy

Symbol.toPrimitiveをサポートするオブジェクトの場合、Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding)を返します。

import { Buffer } from 'node:buffer';

class Foo {
  [Symbol.toPrimitive]() {
    return 'this is a test';
  }
}

const buf = Buffer.from(new Foo(), 'utf8');
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>const { Buffer } = require('node:buffer');

class Foo {
  [Symbol.toPrimitive]() {
    return 'this is a test';
  }
}

const buf = Buffer.from(new Foo(), 'utf8');
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>copy

objectが言及されたメソッドを持たないか、Buffer.from()の他のバリアントに適した他の型でない場合、TypeErrorがスローされます。

静的メソッド: Buffer.from(string[, encoding])#

• string <string> エンコードする文字列。
• encoding <string> stringのエンコーディング。デフォルト: 'utf8'。
• 戻り値: <Buffer>

stringを含む新しいBufferを作成します。encodingパラメータは、stringをバイトに変換する際に使用される文字エンコーディングを特定します。

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ést
console.log(buf2.toString());
// Prints: this is a tést
console.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ést
console.log(buf2.toString());
// Prints: this is a tést
console.log(buf1.toString('latin1'));
// Prints: this is a téstcopy

stringが文字列またはBuffer.from()の他のバリアントに適した他の型でない場合、TypeErrorがスローされます。

Buffer.from(string)は、Buffer.allocUnsafe()のように内部のBufferプールを使用することもあります。

静的メソッド: Buffer.isBuffer(obj)#

• obj <Object>
• 戻り値: <boolean>

objがBufferの場合はtrueを、それ以外の場合はfalseを返します。

import { Buffer } from 'node:buffer';

Buffer.isBuffer(Buffer.alloc(10)); // true
Buffer.isBuffer(Buffer.from('foo')); // true
Buffer.isBuffer('a string'); // false
Buffer.isBuffer([]); // false
Buffer.isBuffer(new Uint8Array(1024)); // falseconst { Buffer } = require('node:buffer');

Buffer.isBuffer(Buffer.alloc(10)); // true
Buffer.isBuffer(Buffer.from('foo')); // true
Buffer.isBuffer('a string'); // false
Buffer.isBuffer([]); // false
Buffer.isBuffer(new Uint8Array(1024)); // falsecopy

静的メソッド: Buffer.isEncoding(encoding)#

• encoding <string> チェックする文字エンコーディング名。
• 戻り値: <boolean>

encodingがサポートされている文字エンコーディングの名前である場合はtrueを、それ以外の場合はfalseを返します。

import { Buffer } from 'node:buffer';

console.log(Buffer.isEncoding('utf8'));
// Prints: true

console.log(Buffer.isEncoding('hex'));
// Prints: true

console.log(Buffer.isEncoding('utf/8'));
// Prints: false

console.log(Buffer.isEncoding(''));
// Prints: falseconst { Buffer } = require('node:buffer');

console.log(Buffer.isEncoding('utf8'));
// Prints: true

console.log(Buffer.isEncoding('hex'));
// Prints: true

console.log(Buffer.isEncoding('utf/8'));
// Prints: false

console.log(Buffer.isEncoding(''));
// Prints: falsecopy

Buffer.poolSize#

• 型: <integer> デフォルト: 8192

これは、プーリングに使用される事前に割り当てられた内部Bufferインスタンスのサイズ（バイト単位）です。この値は変更可能です。

buf[index]#

• index <integer>

インデックス演算子[index]を使用して、buf内の位置indexにあるオクテットを取得および設定できます。値は個々のバイトを参照するため、有効な値の範囲は0x00から0xFF（16進数）または0から255（10進数）の間です。

この演算子はUint8Arrayから継承されているため、範囲外のアクセスに対する動作はUint8Arrayと同じです。つまり、indexが負またはbuf.length以上の場合、buf[index]はundefinedを返し、indexが負または>= buf.lengthの場合、buf[index] = valueはバッファを変更しません。

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> このBufferオブジェクトが作成された基礎となるArrayBufferオブジェクト。

このArrayBufferが元のBufferと正確に対応することは保証されません。詳細については、buf.byteOffsetの注記を参照してください。

import { Buffer } from 'node:buffer';

const arrayBuffer = new ArrayBuffer(16);
const buffer = Buffer.from(arrayBuffer);

console.log(buffer.buffer === arrayBuffer);
// Prints: trueconst { Buffer } = require('node:buffer');

const arrayBuffer = new ArrayBuffer(16);
const buffer = Buffer.from(arrayBuffer);

console.log(buffer.buffer === arrayBuffer);
// Prints: truecopy

buf.byteOffset#

• 型: <integer> Bufferの基礎となるArrayBufferオブジェクトのbyteOffset。

Buffer.from(ArrayBuffer, byteOffset, length)でbyteOffsetを設定する場合、または時々Buffer.poolSizeより小さいBufferを割り当てる場合、バッファは基礎となるArrayBuffer上のゼロオフセットから開始しません。

これは、buf.bufferを使用して基礎となるArrayBufferに直接アクセスするときに問題を引き起こす可能性があります。なぜなら、ArrayBufferの他の部分はBufferオブジェクト自体とは無関係である可能性があるためです。

Bufferとメモリを共有するTypedArrayオブジェクトを作成する際の一般的な問題は、この場合、byteOffsetを正しく指定する必要があることです。

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`.
new Int8Array(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`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length);copy

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

• target <Buffer> | <Uint8Array> bufと比較するBufferまたは<Uint8Array>。
• targetStart <integer> 比較を開始するtarget内のオフセット。デフォルト: 0。
• targetEnd <integer> 比較を終了するtarget内のオフセット（含まない）。デフォルト: target.length。
• sourceStart <integer> 比較を開始するbuf内のオフセット。デフォルト: 0。
• sourceEnd <integer> 比較を終了するbuf内のオフセット（含まない）。デフォルト: buf.length。
• 戻り値: <integer>

bufをtargetと比較し、bufがソート順でtargetの前、後、または同じであるかを示す数値を返します。比較は、各Bufferの実際のバイトシーケンスに基づいています。

• targetがbufと同じ場合、0が返されます。
• ソート時にtargetがbufの*前*に来るべき場合、1が返されます。
• ソート時にtargetがbufの*後*に来るべき場合、-1が返されます。

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: 0
console.log(buf1.compare(buf2));
// Prints: -1
console.log(buf1.compare(buf3));
// Prints: -1
console.log(buf2.compare(buf1));
// Prints: 1
console.log(buf2.compare(buf3));
// Prints: 1
console.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: 0
console.log(buf1.compare(buf2));
// Prints: -1
console.log(buf1.compare(buf3));
// Prints: -1
console.log(buf2.compare(buf1));
// Prints: 1
console.log(buf2.compare(buf3));
// Prints: 1
console.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

オプションのtargetStart、targetEnd、sourceStart、およびsourceEnd引数を使用して、比較をそれぞれtargetとbuf内の特定の範囲に制限できます。

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: 0
console.log(buf1.compare(buf2, 0, 6, 4));
// Prints: -1
console.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: 0
console.log(buf1.compare(buf2, 0, 6, 4));
// Prints: -1
console.log(buf1.compare(buf2, 5, 6, 5));
// Prints: 1copy

targetStart < 0、sourceStart < 0、targetEnd > target.byteLength、またはsourceEnd > source.byteLengthの場合、ERR_OUT_OF_RANGEがスローされます。

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

• target <Buffer> | <Uint8Array> コピー先のBufferまたは<Uint8Array>。
• targetStart <integer> 書き込みを開始するtarget内のオフセット。デフォルト: 0。
• sourceStart <integer> コピーを開始するbufからのオフセット。デフォルト: 0。
• sourceEnd <integer> コピーを停止するbuf内のオフセット（含まない）。デフォルト: buf.length。
• 戻り値: <integer> コピーされたバイト数。

targetのメモリ領域がbufと重なっていても、bufの領域からtargetの領域へデータをコピーします。

TypedArray.prototype.set()は同じ操作を実行し、Node.jsのBufferを含むすべてのTypedArrayで利用可能ですが、異なる関数引数を取ります。

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()#

• 戻り値: <Iterator>

bufの内容から[index, byte]ペアのイテレータを作成して返します。

import { Buffer } from 'node:buffer';

// Log the entire contents of a `Buffer`.

const buf = Buffer.from('buffer');

for (const pair of 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 pair of 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> bufと比較するBufferまたは<Uint8Array>。
• 戻り値: <boolean>

bufとotherBufferの両方がまったく同じバイトを持つ場合はtrueを、それ以外の場合はfalseを返します。buf.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: true
console.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: true
console.log(buf1.equals(buf3));
// Prints: falsecopy

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

• value <string> | <Buffer> | <Uint8Array> | <integer> bufを埋める値。空の値（文字列、Uint8Array、Buffer）は0に強制変換されます。
• offset <integer> bufの埋め込みを開始する前にスキップするバイト数。デフォルト: 0。
• end <integer> bufの埋め込みを停止する場所（含まない）。デフォルト: buf.length。
• encoding <string> valueが文字列の場合のvalueのエンコーディング。デフォルト: 'utf8'。
• 戻り値: <Buffer> bufへの参照。

bufを指定されたvalueで埋めます。offsetとendが指定されない場合、buf全体が埋められます。

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 string
const 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 string
const c = Buffer.allocUnsafe(5).fill('');

console.log(c.fill(''));
// Prints: <Buffer 00 00 00 00 00>copy

valueが文字列、Buffer、または整数でない場合、uint32値に強制変換されます。結果の整数が255（10進数）より大きい場合、bufはvalue & 255で埋められます。

fill()操作の最後の書き込みがマルチバイト文字にかかる場合、bufに収まるその文字のバイトのみが書き込まれます。

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

valueに無効な文字が含まれている場合、それは切り捨てられます。有効なフィルデータが残らない場合、例外がスローされます。

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> 検索する対象。
• byteOffset <integer> buf内で検索を開始する場所。負の場合、オフセットはbufの末尾から計算されます。デフォルト: 0。
• encoding <string> valueが文字列の場合、そのエンコーディングです。デフォルト: 'utf8'。
• 戻り値: <boolean> buf内でvalueが見つかった場合はtrue、それ以外の場合はfalse。

buf.indexOf() !== -1と同等です。

import { Buffer } from 'node:buffer';

const buf = Buffer.from('this is a buffer');

console.log(buf.includes('this'));
// Prints: true
console.log(buf.includes('is'));
// Prints: true
console.log(buf.includes(Buffer.from('a buffer')));
// Prints: true
console.log(buf.includes(97));
// Prints: true (97 is the decimal ASCII value for 'a')
console.log(buf.includes(Buffer.from('a buffer example')));
// Prints: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
// Prints: true
console.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: true
console.log(buf.includes('is'));
// Prints: true
console.log(buf.includes(Buffer.from('a buffer')));
// Prints: true
console.log(buf.includes(97));
// Prints: true (97 is the decimal ASCII value for 'a')
console.log(buf.includes(Buffer.from('a buffer example')));
// Prints: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));
// Prints: true
console.log(buf.includes('this', 4));
// Prints: falsecopy

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

• value <string> | <Buffer> | <Uint8Array> | <integer> 検索する対象。
• byteOffset <integer> buf内で検索を開始する場所。負の場合、オフセットはbufの末尾から計算されます。デフォルト: 0。
• encoding <string> valueが文字列の場合、これはbuf内で検索される文字列のバイナリ表現を決定するために使用されるエンコーディングです。デフォルト: 'utf8'。
• 戻り値: <integer> buf内でvalueが最初に出現したインデックス、またはbufにvalueが含まれていない場合は-1。

valueが

• 文字列の場合、valueはencodingの文字エンコーディングに従って解釈されます。
• Bufferまたは<Uint8Array>の場合、valueは全体として使用されます。部分的なBufferを比較するには、buf.subarrayを使用してください。
• 数値の場合、valueは0から255の間の符号なし8ビット整数値として解釈されます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from('this is a buffer');

console.log(buf.indexOf('this'));
// Prints: 0
console.log(buf.indexOf('is'));
// Prints: 2
console.log(buf.indexOf(Buffer.from('a buffer')));
// Prints: 8
console.log(buf.indexOf(97));
// Prints: 8 (97 is the decimal ASCII value for 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')));
// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));
// Prints: 8

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le');

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'));
// Prints: 4
console.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: 0
console.log(buf.indexOf('is'));
// Prints: 2
console.log(buf.indexOf(Buffer.from('a buffer')));
// Prints: 8
console.log(buf.indexOf(97));
// Prints: 8 (97 is the decimal ASCII value for 'a')
console.log(buf.indexOf(Buffer.from('a buffer example')));
// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));
// Prints: 8

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le');

console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'));
// Prints: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'));
// Prints: 6copy

valueが文字列、数値、またはBufferでない場合、このメソッドはTypeErrorをスローします。valueが数値の場合、それは有効なバイト値、つまり0から255の間の整数に強制変換されます。

byteOffsetが数値でない場合、それは数値に強制変換されます。強制変換の結果がNaNまたは0の場合、バッファ全体が検索されます。この動作はString.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

valueが空の文字列または空のBufferで、byteOffsetがbuf.lengthより小さい場合、byteOffsetが返されます。valueが空でbyteOffsetがbuf.length以上の場合、buf.lengthが返されます。

buf.keys()#

• 戻り値: <Iterator>

bufのキー（インデックス）のイテレータを作成して返します。

import { Buffer } from 'node:buffer';

const buf = Buffer.from('buffer');

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

const buf = Buffer.from('buffer');

for (const key of buf.keys()) {
  console.log(key);
}
// Prints:
//   0
//   1
//   2
//   3
//   4
//   5copy

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

• value <string> | <Buffer> | <Uint8Array> | <integer> 検索する対象。
• byteOffset <integer> buf内で検索を開始する場所。負の場合、オフセットはbufの末尾から計算されます。デフォルト: buf.length - 1。
• encoding <string> valueが文字列の場合、これはbuf内で検索される文字列のバイナリ表現を決定するために使用されるエンコーディングです。デフォルト: 'utf8'。
• 戻り値: <integer> buf内でvalueが最後に出現したインデックス、またはbufにvalueが含まれていない場合は-1。

buf.indexOf()と同一ですが、valueの最初の出現ではなく最後の出現が見つかります。

import { Buffer } from 'node:buffer';

const buf = Buffer.from('this buffer is a buffer');

console.log(buf.lastIndexOf('this'));
// Prints: 0
console.log(buf.lastIndexOf('buffer'));
// Prints: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')));
// Prints: 17
console.log(buf.lastIndexOf(97));
// Prints: 15 (97 is the decimal ASCII value for 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')));
// Prints: -1
console.log(buf.lastIndexOf('buffer', 5));
// Prints: 5
console.log(buf.lastIndexOf('buffer', 4));
// Prints: -1

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le');

console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'));
// Prints: 6
console.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: 0
console.log(buf.lastIndexOf('buffer'));
// Prints: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')));
// Prints: 17
console.log(buf.lastIndexOf(97));
// Prints: 15 (97 is the decimal ASCII value for 'a')
console.log(buf.lastIndexOf(Buffer.from('yolo')));
// Prints: -1
console.log(buf.lastIndexOf('buffer', 5));
// Prints: 5
console.log(buf.lastIndexOf('buffer', 4));
// Prints: -1

const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le');

console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'));
// Prints: 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'));
// Prints: 4copy

valueが文字列、数値、またはBufferでない場合、このメソッドはTypeErrorをスローします。valueが数値の場合、それは有効なバイト値、つまり0から255の間の整数に強制変換されます。

byteOffsetが数値でない場合、それは数値に強制変換されます。{}やundefinedのようにNaNに強制変換される引数は、バッファ全体を検索します。この動作はString.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

valueが空の文字列または空のBufferの場合、byteOffsetが返されます。

buf.length#

• 型: <integer>

buf内のバイト数を返します。

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: 1234

buf.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: 1234

buf.write('some string', 0, 'utf8');

console.log(buf.length);
// Prints: 1234copy

buf.parent#

buf.parentプロパティは、buf.bufferの非推奨のエイリアスです。

buf.readBigInt64BE([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト: 0。
• 戻り値: <bigint>

指定されたoffsetでbufから符号付き、ビッグエンディアンの64ビット整数を読み取ります。

Bufferから読み取られた整数は、2の補数符号付き値として解釈されます。

buf.readBigInt64LE([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト: 0。
• 戻り値: <bigint>

指定されたoffsetでbufから符号付き、リトルエンディアンの64ビット整数を読み取ります。

Bufferから読み取られた整数は、2の補数符号付き値として解釈されます。

buf.readBigUInt64BE([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト: 0。
• 戻り値: <bigint>

指定されたoffsetでbufから符号なし、ビッグエンディアンの64ビット整数を読み取ります。

この関数はreadBigUint64BEエイリアスでも利用可能です。

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> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト: 0。
• 戻り値: <bigint>

指定されたoffsetでbufから符号なし、リトルエンディアンの64ビット整数を読み取ります。

この関数はreadBigUint64LEエイリアスでも利用可能です。

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> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト: 0。
• 戻り値: <number>

指定されたoffsetでbufから64ビット、ビッグエンディアンのdoubleを読み取ります。

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> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト: 0。
• 戻り値: <number>

指定されたoffsetでbufから64ビット、リトルエンディアンのdoubleを読み取ります。

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-270
console.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-270
console.log(buf.readDoubleLE(1));
// Throws ERR_OUT_OF_RANGE.copy

buf.readFloatBE([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト: 0。
• 戻り値: <number>

指定されたoffsetでbufから32ビット、ビッグエンディアンのfloatを読み取ります。

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> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト: 0。
• 戻り値: <number>

指定されたoffsetでbufから32ビット、リトルエンディアンのfloatを読み取ります。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([1, 2, 3, 4]);

console.log(buf.readFloatLE(0));
// Prints: 1.539989614439558e-36
console.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-36
console.log(buf.readFloatLE(1));
// Throws ERR_OUT_OF_RANGE.copy

buf.readInt8([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 1を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定されたoffsetでbufから符号付き8ビット整数を読み取ります。

Bufferから読み取られた整数は、2の補数符号付き値として解釈されます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([-1, 5]);

console.log(buf.readInt8(0));
// Prints: -1
console.log(buf.readInt8(1));
// Prints: 5
console.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: -1
console.log(buf.readInt8(1));
// Prints: 5
console.log(buf.readInt8(2));
// Throws ERR_OUT_OF_RANGE.copy

buf.readInt16BE([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定されたoffsetでbufから符号付き、ビッグエンディアンの16ビット整数を読み取ります。

Bufferから読み取られた整数は、2の補数符号付き値として解釈されます。

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> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定された offset の buf から、符号付きリトルエンディアン 16 ビット整数を読み取ります。

Bufferから読み取られた整数は、2の補数符号付き値として解釈されます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([0, 5]);

console.log(buf.readInt16LE(0));
// Prints: 1280
console.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: 1280
console.log(buf.readInt16LE(1));
// Throws ERR_OUT_OF_RANGE.copy

buf.readInt32BE([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定された offset の buf から、符号付きビッグエンディアン 32 ビット整数を読み取ります。

Bufferから読み取られた整数は、2の補数符号付き値として解釈されます。

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> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定された offset の buf から、符号付きリトルエンディアン 32 ビット整数を読み取ります。

Bufferから読み取られた整数は、2の補数符号付き値として解釈されます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([0, 0, 0, 5]);

console.log(buf.readInt32LE(0));
// Prints: 83886080
console.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: 83886080
console.log(buf.readInt32LE(1));
// Throws ERR_OUT_OF_RANGE.copy

buf.readIntBE(offset, byteLength)#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLength を満たす必要があります。
• byteLength <integer> 読み取るバイト数。0 < byteLength <= 6 を満たす必要があります。
• 戻り値: <integer>

指定された offset の buf から byteLength バイトを読み取り、結果を最大 48 ビットの精度をサポートするビッグエンディアンの 2 の補数符号付き値として解釈します。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);

console.log(buf.readIntBE(0, 6).toString(16));
// Prints: 1234567890ab
console.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: 1234567890ab
console.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> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLength を満たす必要があります。
• byteLength <integer> 読み取るバイト数。0 < byteLength <= 6 を満たす必要があります。
• 戻り値: <integer>

指定された offset の buf から byteLength バイトを読み取り、結果を最大 48 ビットの精度をサポートするリトルエンディアンの 2 の補数符号付き値として解釈します。

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> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 1を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定された offset の buf から符号なし 8 ビット整数を読み取ります。

この関数は readUint8 エイリアスでも利用できます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([1, -2]);

console.log(buf.readUInt8(0));
// Prints: 1
console.log(buf.readUInt8(1));
// Prints: 254
console.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: 1
console.log(buf.readUInt8(1));
// Prints: 254
console.log(buf.readUInt8(2));
// Throws ERR_OUT_OF_RANGE.copy

buf.readUInt16BE([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定された offset の buf から、符号なしビッグエンディアン 16 ビット整数を読み取ります。

この関数は readUint16BE エイリアスでも利用できます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([0x12, 0x34, 0x56]);

console.log(buf.readUInt16BE(0).toString(16));
// Prints: 1234
console.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: 1234
console.log(buf.readUInt16BE(1).toString(16));
// Prints: 3456copy

buf.readUInt16LE([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定された offset の buf から、符号なしリトルエンディアン 16 ビット整数を読み取ります。

この関数は readUint16LE エイリアスでも利用できます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([0x12, 0x34, 0x56]);

console.log(buf.readUInt16LE(0).toString(16));
// Prints: 3412
console.log(buf.readUInt16LE(1).toString(16));
// Prints: 5634
console.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: 3412
console.log(buf.readUInt16LE(1).toString(16));
// Prints: 5634
console.log(buf.readUInt16LE(2).toString(16));
// Throws ERR_OUT_OF_RANGE.copy

buf.readUInt32BE([offset])#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定された offset の buf から、符号なしビッグエンディアン 32 ビット整数を読み取ります。

この関数は readUint32BE エイリアスでも利用できます。

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> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト: 0。
• 戻り値: <integer>

指定された offset の buf から、符号なしリトルエンディアン 32 ビット整数を読み取ります。

この関数は readUint32LE エイリアスでも利用できます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);

console.log(buf.readUInt32LE(0).toString(16));
// Prints: 78563412
console.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: 78563412
console.log(buf.readUInt32LE(1).toString(16));
// Throws ERR_OUT_OF_RANGE.copy

buf.readUIntBE(offset, byteLength)#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLength を満たす必要があります。
• byteLength <integer> 読み取るバイト数。0 < byteLength <= 6 を満たす必要があります。
• 戻り値: <integer>

指定された offset の buf から byteLength バイトを読み取り、結果を最大 48 ビットの精度をサポートする符号なしビッグエンディアン整数として解釈します。

この関数は readUintBE エイリアスでも利用できます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);

console.log(buf.readUIntBE(0, 6).toString(16));
// Prints: 1234567890ab
console.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: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16));
// Throws ERR_OUT_OF_RANGE.copy

buf.readUIntLE(offset, byteLength)#

• offset <integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLength を満たす必要があります。
• byteLength <integer> 読み取るバイト数。0 < byteLength <= 6 を満たす必要があります。
• 戻り値: <integer>

指定された offset の buf から byteLength バイトを読み取り、結果を最大 48 ビットの精度をサポートする符号なしリトルエンディアン整数として解釈します。

この関数は readUintLE エイリアスでも利用できます。

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> 新しい Buffer が開始する場所。デフォルト: 0。
• end <integer> 新しい Buffer が終了する場所 (このインデックスは含まれません)。デフォルト: buf.length。
• 戻り値: <Buffer>

元の Buffer と同じメモリを参照する新しい Buffer を返しますが、start と end インデックスによってオフセットおよび切り取られます。

buf.length より大きい end を指定すると、end が buf.length と等しい場合と同じ結果が返されます。

このメソッドは TypedArray.prototype.subarray() から継承されます。

新しい Buffer スライスを変更すると、2つのオブジェクトの割り当てられたメモリが重複しているため、元の Buffer のメモリが変更されます。

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: abc

buf1[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: abc

buf1[0] = 33;

console.log(buf2.toString('ascii', 0, buf2.length));
// Prints: !bccopy

負のインデックスを指定すると、スライスは buf の先頭からではなく、末尾から相対的に生成されます。

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> 新しい Buffer が開始する場所。デフォルト: 0。
• end <integer> 新しい Buffer が終了する場所 (このインデックスは含まれません)。デフォルト: buf.length。
• 戻り値: <Buffer>

元の Buffer と同じメモリを参照する新しい Buffer を返しますが、start と end インデックスによってオフセットおよび切り取られます。

このメソッドは Buffer のスーパークラスである Uint8Array.prototype.slice() と互換性がありません。スライスをコピーするには、Uint8Array.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: cuffer

console.log(buf.toString());
// Prints: buffer

// With buf.slice(), the original buffer is modified.
const notReallyCopiedBuf = buf.slice();
notReallyCopiedBuf[0]++;
console.log(notReallyCopiedBuf.toString());
// Prints: cuffer
console.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: cuffer

console.log(buf.toString());
// Prints: buffer

// With buf.slice(), the original buffer is modified.
const notReallyCopiedBuf = buf.slice();
notReallyCopiedBuf[0]++;
console.log(notReallyCopiedBuf.toString());
// Prints: cuffer
console.log(buf.toString());
// Also prints: cuffer (!)copy

buf.swap16()#

• 戻り値: <Buffer> bufへの参照。

buf を符号なし 16 ビット整数の配列として解釈し、バイト順をインプレースでスワップします。buf.length が 2 の倍数でない場合、ERR_INVALID_BUFFER_SIZE をスローします。

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

buf.swap16() の便利な使い方の1つは、UTF-16 リトルエンディアンと UTF-16 ビッグエンディアン間の高速なインプレース変換を実行することです。

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()#

• 戻り値: <Buffer> bufへの参照。

buf を符号なし 32 ビット整数の配列として解釈し、バイト順をインプレースでスワップします。buf.length が 4 の倍数でない場合、ERR_INVALID_BUFFER_SIZE をスローします。

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()#

• 戻り値: <Buffer> bufへの参照。

buf を 64 ビット数の配列として解釈し、バイト順をインプレースでスワップします。buf.length が 8 の倍数でない場合、ERR_INVALID_BUFFER_SIZE をスローします。

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()#

• 戻り値: <Object>

buf の JSON 表現を返します。JSON.stringify() は、Buffer インスタンスを文字列化するときにこの関数を暗黙的に呼び出します。

Buffer.from() は、このメソッドから返される形式のオブジェクトを受け入れます。特に、Buffer.from(buf.toJSON()) は Buffer.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> 使用する文字エンコーディング。デフォルト: 'utf8'。
• start <integer> デコードを開始するバイトオフセット。デフォルト: 0。
• end <integer> デコードを停止するバイトオフセット (このオフセットは含まれません)。デフォルト: buf.length。
• 戻り値: <string>

encoding で指定された文字エンコーディングに従って buf を文字列にデコードします。start と end を渡して buf のサブセットのみをデコードすることができます。

encoding が 'utf8' で、入力のバイトシーケンスが有効な UTF-8 でない場合、無効な各バイトは置換文字 U+FFFD に置き換えられます。

文字列インスタンスの最大長 (UTF-16 コードユニット単位) は buffer.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: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5));
// Prints: abcde

const buf2 = Buffer.from('tést');

console.log(buf2.toString('hex'));
// Prints: 74c3a97374
console.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: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5));
// Prints: abcde

const buf2 = Buffer.from('tést');

console.log(buf2.toString('hex'));
// Prints: 74c3a97374
console.log(buf2.toString('utf8', 0, 3));
// Prints: té
console.log(buf2.toString(undefined, 0, 3));
// Prints: técopy

buf.values()#

• 戻り値: <Iterator>

buf の値 (バイト) の イテレータ を作成して返します。この関数は、Buffer が for..of 文で使用されるときに自動的に呼び出されます。

import { Buffer } from 'node:buffer';

const buf = Buffer.from('buffer');

for (const value of buf.values()) {
  console.log(value);
}
// Prints:
//   98
//   117
//   102
//   102
//   101
//   114

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

const buf = Buffer.from('buffer');

for (const value of buf.values()) {
  console.log(value);
}
// Prints:
//   98
//   117
//   102
//   102
//   101
//   114

for (const value of buf) {
  console.log(value);
}
// Prints:
//   98
//   117
//   102
//   102
//   101
//   114copy

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

• string <string> buf に書き込む文字列。
• offset <integer> string の書き込みを開始する前にスキップするバイト数。デフォルト: 0。
• length <integer> 書き込む最大バイト数 (書き込まれるバイトは buf.length - offset を超えません)。デフォルト: buf.length - offset。
• encoding <string> string の文字エンコーディング。デフォルト: 'utf8'。
• 戻り値: <integer> 書き込まれたバイト数。

encoding の文字エンコーディングに従って、offset の位置に string を buf に書き込みます。length パラメータは書き込むバイト数です。buf に文字列全体を収めるのに十分なスペースがない場合、string の一部のみが書き込まれます。ただし、部分的にエンコードされた文字は書き込まれません。

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> buf に書き込まれる数値。
• offset <integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8 を満たす必要があります。デフォルト: 0。
• 戻り値: <integer> offset に書き込まれたバイト数を加えた値。

指定された offset の buf に value をビッグエンディアンで書き込みます。

value は 2 の補数符号付き整数として解釈および書き込まれます。

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> buf に書き込まれる数値。
• offset <integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8 を満たす必要があります。デフォルト: 0。
• 戻り値: <integer> offset に書き込まれたバイト数を加えた値。

指定された offset の buf に value をリトルエンディアンで書き込みます。

value は 2 の補数符号付き整数として解釈および書き込まれます。

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> buf に書き込まれる数値。
• offset <integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8 を満たす必要があります。デフォルト: 0。
• 戻り値: <integer> offset に書き込まれたバイト数を加えた値。

指定された offset の buf に value をビッグエンディアンで書き込みます。

この関数は writeBigUint64BE エイリアスでも利用できます。

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> buf に書き込まれる数値。
• offset <integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8 を満たす必要があります。デフォルト: 0。
• 戻り値: <integer> offset に書き込まれたバイト数を加えた値。

指定された offset の buf に value をリトルエンディアンで書き込みます。

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

この関数は writeBigUint64LE エイリアスでも利用できます。

buf.writeDoubleBE(value[, offset])#

• value <number> buf に書き込まれる数値。
• offset <integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8 を満たす必要があります。デフォルト: 0。
• 戻り値: <integer> offset に書き込まれたバイト数を加えた値。

指定された offset の buf に value をビッグエンディアンで書き込みます。value は JavaScript の数値である必要があります。value が JavaScript の数値以外の場合、動作は未定義です。

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> buf に書き込まれる数値。
• offset <integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8 を満たす必要があります。デフォルト: 0。
• 戻り値: <integer> offset に書き込まれたバイト数を加えた値。

指定された offset の buf に value をリトルエンディアンで書き込みます。value は JavaScript の数値である必要があります。value が JavaScript の数値以外の場合、動作は未定義です。

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> buf に書き込まれる数値。
• offset <integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4 を満たす必要があります。デフォルト: 0。
• 戻り値: <integer> offset に書き込まれたバイト数を加えた値。

指定された offset の buf に value をビッグエンディアンで書き込みます。value が JavaScript の数値以外の場合、動作は未定義です。

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])#