Node.js v21.7.2 文件

Buffer 和字元編碼#

在 Buffer 和字串之間轉換時，可以指定字元編碼。如果未指定字元編碼，UTF-8 將會作為預設值。

import { Buffer } from 'node:buffer';

const buf = Buffer.from('hello world', 'utf8');

console.log(buf.toString('hex'));
// Prints: 68656c6c6f20776f726c64
console.log(buf.toString('base64'));
// Prints: aGVsbG8gd29ybGQ=

console.log(Buffer.from('fhqwhgads', 'utf8'));
// Prints: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'));
// Prints: <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>const { Buffer } = require('node:buffer');

const buf = Buffer.from('hello world', 'utf8');

console.log(buf.toString('hex'));
// Prints: 68656c6c6f20776f726c64
console.log(buf.toString('base64'));
// Prints: aGVsbG8gd29ybGQ=

console.log(Buffer.from('fhqwhgads', 'utf8'));
// Prints: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'));
// Prints: <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>copy

Node.js 緩衝區接受所有大小寫變體的編碼字串。例如，UTF-8 可以指定為 'utf8'、'UTF8' 或 'uTf8'。

Node.js 目前支援下列字元編碼

• 'utf8'（別名：'utf-8'）：多位元組編碼的 Unicode 字元。許多網頁和其他文件格式使用 UTF-8。這是預設的字元編碼。當將 Buffer 解碼為不只包含有效 UTF-8 資料的字串時，Unicode 替換字元 U+FFFD � 將會用來表示這些錯誤。

• 'utf16le'（別名：'utf-16le'）：多位元組編碼的 Unicode 字元。與 'utf8' 不同，字串中的每個字元將使用 2 或 4 個位元組編碼。Node.js 僅支援 小端序 變體的 UTF-16。

• 'latin1'：Latin-1 代表 ISO-8859-1。此字元編碼僅支援從 U+0000 到 U+00FF 的 Unicode 字元。每個字元使用一個位元組編碼。不符合此範圍的字元將會被截斷並對應到此範圍內的字元。

使用上述編碼之一將 Buffer 轉換為字串稱為解碼，而將字串轉換為 Buffer 稱為編碼。

Node.js 也支援下列二進制轉文字編碼。對於二進制轉文字編碼，命名慣例是相反的：將 Buffer 轉換為字串通常稱為編碼，而將字串轉換為 Buffer 則稱為解碼。

• 'base64'：Base64 編碼。在從字串建立 Buffer 時，此編碼也會正確接受 RFC 4648 第 5 節 中指定的「URL 和檔案名稱安全字母」。base64 編碼字串中包含的空白字元（例如空格、標籤和換行）會被忽略。

• 'base64url'：base64url 編碼，如 RFC 4648 第 5 節 中所指定。在從字串建立 Buffer 時，此編碼也會正確接受一般的 base64 編碼字串。在將 Buffer 編碼為字串時，此編碼會省略填補。

• 'hex'：將每個位元組編碼為兩個十六進位字元。在解碼不完全由偶數個十六進位字元組成的字串時，可能會發生資料截斷。請參閱下方範例。

也支援下列舊版字元編碼

• 'ascii'：僅適用於 7 位元 ASCII 資料。在將字串編碼為 Buffer 時，這等同於使用 'latin1'。在將 Buffer 解碼為字串時，使用此編碼會在解碼為 'latin1' 之前，另外取消設定每個位元組的最高位元。一般來說，沒有理由使用此編碼，因為在編碼或解碼僅包含 ASCII 的文字時，'utf8'（或如果已知資料永遠只包含 ASCII，則為 'latin1'）會是較好的選擇。它僅提供舊版相容性。

• 'binary'：'latin1' 的別名。此編碼的名稱可能會造成誤導，因為這裡列出的所有編碼都在字串和二進制資料之間進行轉換。對於在字串和 Buffer 之間進行轉換，通常 'utf8' 是正確的選擇。

• 'ucs2'、'ucs-2'：'utf16le' 的別名。UCS-2 過去指的是一種 UTF-16 變體，不支援碼點大於 U+FFFF 的字元。在 Node.js 中，這些碼點永遠都受支援。

import { Buffer } from 'node:buffer';

Buffer.from('1ag123', 'hex');
// Prints <Buffer 1a>, data truncated when first non-hexadecimal value
// ('g') encountered.

Buffer.from('1a7', 'hex');
// Prints <Buffer 1a>, data truncated when data ends in single digit ('7').

Buffer.from('1634', 'hex');
// Prints <Buffer 16 34>, all data represented.const { Buffer } = require('node:buffer');

Buffer.from('1ag123', 'hex');
// Prints <Buffer 1a>, data truncated when first non-hexadecimal value
// ('g') encountered.

Buffer.from('1a7', 'hex');
// Prints <Buffer 1a>, data truncated when data ends in single digit ('7').

Buffer.from('1634', 'hex');
// Prints <Buffer 16 34>, all data represented.copy

現代網路瀏覽器遵循 WHATWG 編碼標準，將 'latin1' 和 'ISO-8859-1' 別名設為 'win-1252'。這表示執行類似 http.get() 的動作時，如果傳回的字元集是 WHATWG 規格中列出的字元集之一，則伺服器實際上傳回的是 'win-1252' 編碼資料，而使用 'latin1' 編碼可能會錯誤解碼字元。

緩衝區和型化陣列#

Buffer 實例也是 JavaScript Uint8Array 和 TypedArray 實例。Buffer 上可以使用所有 TypedArray 方法。不過，Buffer API 和 TypedArray API 之間存在一些細微的不相容性。

特別是

• 雖然 TypedArray.prototype.slice() 會建立 TypedArray 一部分的副本，但 Buffer.prototype.slice() 會在現有的 Buffer 上建立一個檢視，而不會複製。這種行為可能會令人驚訝，而且只存在於舊版相容性中。TypedArray.prototype.subarray() 可用於在 Buffer 和其他 TypedArray 上達成 Buffer.prototype.slice() 的行為，而且應該優先使用。
• buf.toString() 與其 TypedArray 等效項不相容。
• 許多方法（例如 buf.indexOf()）支援額外的引數。

有兩種方法可以從 TypedArray 執行個體建立新的 Buffer

• 傳遞 Buffer 給 TypedArray 建構函數將會複製 Buffer 的內容，將其解釋為整數陣列，而不是目標類型的位元組序列。

import { Buffer } from 'node:buffer';

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

console.log(uint32array);

// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]const { Buffer } = require('node:buffer');

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

console.log(uint32array);

// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]copy

• 傳遞 Buffer 底層的 ArrayBuffer 將會建立一個 TypedArray，它與 Buffer 共用記憶體。

import { Buffer } from 'node:buffer';

const buf = Buffer.from('hello', 'utf16le');
const uint16array = new Uint16Array(
  buf.buffer,
  buf.byteOffset,
  buf.length / Uint16Array.BYTES_PER_ELEMENT);

console.log(uint16array);

// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]const { Buffer } = require('node:buffer');

const buf = Buffer.from('hello', 'utf16le');
const uint16array = new Uint16Array(
  buf.buffer,
  buf.byteOffset,
  buf.length / Uint16Array.BYTES_PER_ELEMENT);

console.log(uint16array);

// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]copy

可以透過使用 TypedArray 物件的 .buffer 屬性，以相同的方式建立一個新的 Buffer，它與 TypedArray 執行個體共用相同的已配置記憶體。在此情況下，Buffer.from() 的行為類似於 new Uint8Array()。

import { Buffer } from 'node:buffer';

const arr = new Uint16Array(2);

arr[0] = 5000;
arr[1] = 4000;

// Copies the contents of `arr`.
const buf1 = Buffer.from(arr);

// Shares memory with `arr`.
const buf2 = Buffer.from(arr.buffer);

console.log(buf1);
// Prints: <Buffer 88 a0>
console.log(buf2);
// Prints: <Buffer 88 13 a0 0f>

arr[1] = 6000;

console.log(buf1);
// Prints: <Buffer 88 a0>
console.log(buf2);
// Prints: <Buffer 88 13 70 17>const { Buffer } = require('node:buffer');

const arr = new Uint16Array(2);

arr[0] = 5000;
arr[1] = 4000;

// Copies the contents of `arr`.
const buf1 = Buffer.from(arr);

// Shares memory with `arr`.
const buf2 = Buffer.from(arr.buffer);

console.log(buf1);
// Prints: <Buffer 88 a0>
console.log(buf2);
// Prints: <Buffer 88 13 a0 0f>

arr[1] = 6000;

console.log(buf1);
// Prints: <Buffer 88 a0>
console.log(buf2);
// Prints: <Buffer 88 13 70 17>copy

在使用 TypedArray 的 .buffer 建立 Buffer 時，可以透過傳入 byteOffset 和 length 參數，僅使用底層 ArrayBuffer 的一部分。

import { Buffer } from 'node:buffer';

const arr = new Uint16Array(20);
const buf = Buffer.from(arr.buffer, 0, 16);

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

const arr = new Uint16Array(20);
const buf = Buffer.from(arr.buffer, 0, 16);

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

Buffer.from() 和 TypedArray.from() 具有不同的簽章和實作。特別是，TypedArray 變體接受第二個參數，該參數是對類型化陣列每個元素呼叫的對應函數

• TypedArray.from(source[, mapFn[, thisArg]])

但是，Buffer.from() 方法不支援使用對應函數

• Buffer.from(array)
• Buffer.from(buffer)
• Buffer.from(arrayBuffer[, byteOffset[, length]])
• Buffer.from(string[, encoding])

緩衝區和反覆運算#

可以使用 for..of 語法對 Buffer 執行個體反覆運算

import { Buffer } from 'node:buffer';

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

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

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

for (const b of buf) {
  console.log(b);
}
// Prints:
//   1
//   2
//   3copy

此外，buf.values()、buf.keys() 和 buf.entries() 方法可用於建立反覆運算器。

類別：Blob#

Blob 封裝不可變的原始資料，可以在多個工作執行緒中安全地共用。

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

• sources <string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> 陣列的字串、<ArrayBuffer>、<TypedArray>、<DataView> 或 <Blob> 物件，或任何此類物件的組合，將儲存在 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>

傳回一個 Promise，其中包含一個 <ArrayBuffer>，其中包含 Blob 資料的副本。

blob.size#

Blob 的總大小（以位元組為單位）。

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

• start <number> 起始索引。
• end <number> 結束索引。
• type <string> 新 Blob 的內容類型

建立並傳回一個新的 Blob，其中包含這個 Blob 物件資料的子集。原始的 Blob 沒有被變更。

blob.stream()#

• 傳回： <ReadableStream>

傳回一個新的 ReadableStream，允許讀取 Blob 的內容。

blob.text()#

• 傳回： <Promise>

傳回一個 Promise，其中包含已解碼為 UTF-8 字串的 Blob 內容。

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#

Buffer 類別是直接處理二進位資料的全球類型。它可以使用多種方式建構。

靜態方法：Buffer.alloc(size[, fill[, encoding]])#

• size <整數> 新 Buffer 的所需長度。
• fill <字串> | <Buffer> | <Uint8Array> | <整數> 預先填入新 Buffer 的值。預設值：0。
• encoding <字串> 如果 fill 是字串，這是其編碼。預設值：'utf8'。

配置一個大小為 size 位元組的新 Buffer。如果 fill 是 undefined，Buffer 將會填滿 0。

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，將會透過呼叫 buf.fill(fill) 來初始化配置的 Buffer。

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，將會透過呼叫 buf.fill(fill, encoding) 來初始化配置的 Buffer。

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 <整數> 新 Buffer 的所需長度。

配置一個大小為 size 位元組的新 Buffer。如果 size 大於 buffer.constants.MAX_LENGTH 或小於 0，則會擲回 ERR_OUT_OF_RANGE。

使用這種方式建立的 Buffer 實例的底層記憶體未初始化。新建立的 Buffer 內容未知，可能包含敏感資料。請改用 Buffer.alloc() 來使用零初始化 Buffer 實例。

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 實例，用作使用 Buffer.allocUnsafe()、Buffer.from(array) 和 Buffer.concat() 建立的新 Buffer 實例的快速配置池，但僅限於 size 小於 Buffer.poolSize >>> 1（Buffer.poolSize 除以 2 的商）時。

使用這個預先配置的內部記憶體池是呼叫 Buffer.alloc(size, fill) 與 Buffer.allocUnsafe(size).fill(fill) 的主要差異。特別是，Buffer.alloc(size, fill) 永遠不會使用內部 Buffer 池，而 Buffer.allocUnsafe(size).fill(fill) 會使用內部 Buffer 池，如果 size 小於或等於 Buffer.poolSize 的一半。差異很細微，但當應用程式需要 Buffer.allocUnsafe() 提供的額外效能時，就很重要。

靜態方法：Buffer.allocUnsafeSlow(size)#

• size <整數> 新 Buffer 的所需長度。

配置一個大小為 size 位元的 Buffer。如果 size 大於 buffer.constants.MAX_LENGTH 或小於 0，則會擲回 ERR_OUT_OF_RANGE。如果 size 為 0，則會建立一個長度為 0 的 Buffer。

使用這種方式建立的 Buffer 實例的底層記憶體未初始化。新建立的 Buffer 內容未知，可能包含敏感資料。請使用 buf.fill(0) 來使用零初始化這些 Buffer 實例。

使用 Buffer.allocUnsafe() 分配新的 Buffer 執行個體時，小於 4 KiB 的分配會從單一預先分配的 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>

傳回一個新的 Buffer，它是串聯 list 中所有 Buffer 執行個體的結果。

如果清單沒有項目，或如果 totalLength 為 0，則傳回一個新的零長度 Buffer。

如果未提供 totalLength，則透過新增 list 中 Buffer 執行個體的長度來從中計算。

如果提供了 totalLength，則會將其強制轉換為無符號整數。如果 list 中 Buffer 的合併長度超過 totalLength，則結果會被截斷為 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 池，就像 Buffer.allocUnsafe() 一樣。

靜態方法：Buffer.copyBytesFrom(view[, offset[, length]])#

• view <TypedArray> 要複製的 <TypedArray>。
• offset <整數> view 內的起始偏移量。預設值：：0。
• length <整數> 從 view 複製元素的數量。預設值： view.length - offset。

將 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 <整數[]>

使用範圍在 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 的物件（也就是具有 length 屬性的 number 類型），則會將它視為陣列，除非它是 Buffer 或 Uint8Array。這表示所有其他 TypedArray 變體都會被視為 Array。若要從支援 TypedArray 的位元組建立 Buffer，請使用 Buffer.copyBytesFrom()。

如果 array 不是 Array 或其他適用於 Buffer.from() 變體的類型，則會擲回 TypeError。

Buffer.from(array) 和 Buffer.from(string) 也可能使用內部 Buffer 池，就像 Buffer.allocUnsafe() 一樣。

靜態方法：Buffer.from(arrayBuffer[, byteOffset[, length]])#

• arrayBuffer <ArrayBuffer> | <SharedArrayBuffer> 一個 ArrayBuffer，SharedArrayBuffer，例如 TypedArray 的 .buffer 屬性。
• byteOffset <integer> 要公開的第一個位元組的索引。預設：0。
• length <integer> 要公開的位元組數。預設：arrayBuffer.byteLength - byteOffset。

這會建立 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 參數指定 arrayBuffer 內部 Buffer 將共用的記憶體範圍。

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 實例上。

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> 長度。

對於其 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。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.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#

• <整數> 預設值：8192

這是用於合併的預先配置內部 Buffer 執行個體的大小（以位元組為單位）。這個值可以修改。

buf[index]#

• index <整數>

索引運算子 [index] 可用於取得和設定 buf 中位置 index 的八位元組。這些值指個別的位元組，因此合法的值範圍介於 0x00 和 0xFF（十六進位）或 0 和 255（十進位）之間。

這個運算子繼承自 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#

• <整數> 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> 複製的位元組數。

將 buf 中的區域資料複製到 target 中的區域，即使 target 記憶體區域與 buf 重疊。

TypedArray.prototype.set() 執行相同的操作，且可供所有 TypedArray 使用，包括 Node.js Buffer，儘管它採用不同的函式引數。

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 的參考。

使用指定的 value 填入 buf。如果未提供 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（十進位），則會使用 value & 255 填入 buf。

如果 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 <字串> | <Buffer> | <Uint8Array> | <整數> 要搜尋的內容。
• byteOffset <整數> 開始在 buf 中搜尋的位置。如果是負數，則會從 buf 的結尾開始計算偏移量。預設：0。
• encoding <字串> 如果 value 是字串，則這是它的編碼。預設：'utf8'。
• 傳回：<布林值> 如果在 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 <字串> | <Buffer> | <Uint8Array> | <整數> 要搜尋的內容。
• byteOffset <整數> 開始在 buf 中搜尋的位置。如果是負數，則會從 buf 的結尾開始計算偏移量。預設：0。
• 編碼 <字串> 如果 值 是字串，這是用來決定將在 buf 中搜尋的字串二進制表示法的編碼。預設： 'utf8'。
• 傳回： <整數> 值 在 buf 中第一次出現的索引，或 -1（如果 buf 不包含 值）。

如果 值 是

• 字串，值 會根據 編碼 中的字元編碼來詮釋。
• Buffer 或 Uint8Array，值 會完整使用。若要比較部分 Buffer，請使用 buf.subarray。
• 數字，值 會被詮釋為介於 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

如果 值 不是字串、數字或 Buffer，這個方法會擲出 TypeError。如果 值 是數字，它會被強制轉換為有效的位元組值，介於 0 和 255 之間的整數。

如果 位元組偏移量 不是數字，它會被強制轉換為數字。如果強制轉換的結果是 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

如果 值 是空字串或空 Buffer，且 位元組偏移量 小於 buf.length，會傳回 位元組偏移量。如果 值 是空且 位元組偏移量 至少為 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 <字串> | <Buffer> | <Uint8Array> | <整數> 要搜尋的內容。
• 位元組偏移量 <整數> 在 buf 中開始搜尋的位置。如果是負數，偏移量會從 buf 的結尾計算。預設： buf.length - 1。
• 編碼 <字串> 如果 值 是字串，這是用來決定將在 buf 中搜尋的字串二進制表示法的編碼。預設： 'utf8'。
• 傳回：<整數> value 在 buf 中最後出現的索引，如果 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

如果 值 不是字串、數字或 Buffer，這個方法會擲出 TypeError。如果 值 是數字，它會被強制轉換為有效的位元組值，介於 0 和 255 之間的整數。

如果 byteOffset 不是數字，它將被強制轉換為數字。任何強制轉換為 NaN 的參數，例如 {} 或 undefined，將搜尋整個緩衝區。此行為與 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#

• <整數>

傳回 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 <整數> 開始讀取前要跳過的位元組數。必須符合：0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<bigint>

從 buf 中指定 offset 的位置讀取一個已簽署的大端序 64 位元整數。

從 Buffer 讀取的整數會被解釋為二補數的已簽署值。

buf.readBigInt64LE([offset])#

• offset <整數> 開始讀取前要跳過的位元組數。必須符合：0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<bigint>

從 buf 中指定 offset 的位置讀取一個已簽署的小端序 64 位元整數。

從 Buffer 讀取的整數會被解釋為二補數的已簽署值。

buf.readBigUInt64BE([offset])#

• offset <整數> 開始讀取前要跳過的位元組數。必須符合：0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<bigint>

從 buf 中指定 offset 的位置讀取一個未簽署的大端序 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 <整數> 開始讀取前要跳過的位元組數。必須符合：0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<bigint>

從 buf 中指定 offset 的位置讀取一個未簽署的小端序 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 <整數> 開始讀取前的跳過位元組數。必須符合 0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<數字>

從 buf 中指定 offset 的位置讀取一個 64 位元的大端序雙精度浮點數。

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 <整數> 開始讀取前的跳過位元組數。必須符合 0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<數字>

從 buf 中指定 offset 的位置讀取一個 64 位元的小端序雙精度浮點數。

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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 4。預設：0。
• 傳回：<數字>

從 buf 的指定 offset 讀取 32 位元，大端序浮點數。

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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 4。預設：0。
• 傳回：<數字>

從 buf 的指定 offset 讀取 32 位元，小端序浮點數。

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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 1。預設：0。
• 傳回： <integer>

從 buf 的指定 offset 讀取一個有號 8 位元整數。

從 Buffer 讀取的整數會被解釋為二補數的已簽署值。

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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 2。預設：0。
• 傳回： <integer>

從 buf 的指定 offset 讀取一個有號，大端序 16 位元整數。

從 Buffer 讀取的整數會被解釋為二補數的已簽署值。

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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 2。預設：0。
• 傳回： <integer>

從 buf 中的指定 offset 處讀取一個有號小端序 16 位元整數。

從 Buffer 讀取的整數會被解釋為二補數的已簽署值。

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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 4。預設：0。
• 傳回： <integer>

從 buf 中的指定 offset 處讀取一個有號大端序 32 位元整數。

從 Buffer 讀取的整數會被解釋為二補數的已簽署值。

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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 4。預設：0。
• 傳回： <integer>

從 buf 中的指定 offset 處讀取一個有號小端序 32 位元整數。

從 Buffer 讀取的整數會被解釋為二補數的已簽署值。

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>

從 buf 中的指定 offset 處讀取 byteLength 數量的位元組，並將結果解釋為大端序、二補數有號值，支援最高 48 位元精確度。

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>

從 buf 中的指定 offset 處讀取 byteLength 數量的位元組，並將結果解釋為小端序、二補數有號值，支援最高 48 位元精確度。

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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 1。預設：0。
• 傳回： <integer>

從 buf 中的指定 offset 讀取一個未簽署的 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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 2。預設：0。
• 傳回： <integer>

從 buf 中的指定 offset 讀取一個未簽署的 big-endian 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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 2。預設：0。
• 傳回： <integer>

從 buf 中的指定 offset 讀取一個未簽署的 little-endian 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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 4。預設：0。
• 傳回： <integer>

從 buf 中的指定 offset 讀取一個未簽署的 big-endian 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 <整數> 開始讀取前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 4。預設：0。
• 傳回： <integer>

從 buf 中的指定 offset 讀取一個未簽署的 little-endian 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>

從 buf 的指定 offset 讀取 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>

從 buf 的指定 offset 讀取 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 <整數> 新 Buffer 的起始位置。預設值：0。
• end <整數> 新 Buffer 的結束位置（不包含）。預設值： buf.length。
• 傳回：<Buffer>

傳回一個新的 Buffer，它參照與原始 Buffer 相同的記憶體，但由 start 和 end 索引進行偏移和裁切。

指定大於 buf.length 的 end 會傳回與 end 等於 buf.length 相同的結果。

此方法繼承自 TypedArray.prototype.subarray()。

修改新的 Buffer 切片會修改原始 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 <整數> 新 Buffer 的起始位置。預設值：0。
• end <整數> 新 Buffer 的結束位置（不包含）。預設值： buf.length。
• 傳回：<Buffer>

傳回一個新的 Buffer，它參照與原始 Buffer 相同的記憶體，但由 start 和 end 索引進行偏移和裁切。

此方法與 Uint8Array.prototype.slice() 不相容，後者是 Buffer 的超類別。若要複製切片，請使用 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() 的一個便利用途是在 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 表示。當將 Buffer 執行個體字串化時，JSON.stringify() 會隱含呼叫此函式。

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 中的字元編碼，將 string 寫入 buf 的 offset。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 <整數> 開始寫入前要跳過的位元組數。必須符合：0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<整數> offset 加上已寫入的位元組數。

將 value 以大端序寫入 buf 的指定 offset。

value 會被解譯並寫入為二補數有號整數。

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 <整數> 開始寫入前要跳過的位元組數。必須符合：0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<整數> offset 加上已寫入的位元組數。

將 value 以小端序寫入 buf 的指定 offset。

value 會被解譯並寫入為二補數有號整數。

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 <整數> 開始寫入前要跳過的位元組數。必須符合：0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<整數> offset 加上已寫入的位元組數。

將 value 以大端序寫入 buf 的指定 offset。

此函數也可在 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 <整數> 開始寫入前要跳過的位元組數。必須符合：0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<整數> offset 加上已寫入的位元組數。

將 value 以小端序寫入 buf 的指定 offset

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 <數字> 要寫入 buf 的數字。
• offset <整數> 開始寫入前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<整數> offset 加上已寫入的位元組數。

將 value 以大端序寫入 buf 中指定的 offset。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 <數字> 要寫入 buf 的數字。
• offset <整數> 開始寫入前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 8。預設值：0。
• 傳回：<整數> offset 加上已寫入的位元組數。

將 value 以小端序寫入 buf 中指定的 offset。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 <數字> 要寫入 buf 的數字。
• offset <整數> 開始寫入前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 4。預設值：0。
• 傳回：<整數> offset 加上已寫入的位元組數。

將 value 以大端序寫入 buf 中指定的 offset。當 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])#

• value <數字> 要寫入 buf 的數字。
• offset <整數> 開始寫入前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 4。預設值：0。
• 傳回：<整數> offset 加上已寫入的位元組數。

將 value 以小端序寫入 buf 中指定的 offset。當 value 不是 JavaScript 數字時，行為未定義。

import { Buffer } from 'node:buffer';

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

console.log(buf);
// Prints: <Buffer bb fe 4a 4f>const { Buffer } = require('node:buffer');

const buf = Buffer.allocUnsafe(4);

buf.writeFloatLE(0xcafebabe, 0);

console.log(buf);
// Prints: <Buffer bb fe 4a 4f>copy

buf.writeInt8(value[, offset])#

• value <整數> 要寫入 buf 的數字。
• offset <整數> 開始寫入前要跳過的位元組數。必須符合 0 <= offset <= buf.length - 1。預設：0。
• 傳回：<整數> offset 加上已寫入的位元組數。