Node.js v24.0.0 文档

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，该 Promise 使用包含 Blob 数据副本的 <ArrayBuffer> 来实现。

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>

返回一个新的 ReadableStream，允许读取 Blob 的内容。

blob.text()#

• 返回：<Promise>

返回一个 Promise，该 Promise 使用解码为 UTF-8 字符串的 Blob 的内容来实现。

blob.type#

• 类型：<string>

Blob 的内容类型。

Blob 对象和 MessageChannel#

创建 <Blob> 对象后，可以通过 MessagePort 将其发送到多个目标，而无需传输或立即复制数据。 仅当调用 arrayBuffer() 或 text() 方法时，才会复制 Blob 包含的数据。

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，则将通过调用 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 <integer> 新 Buffer 的期望长度。
• 返回值: <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.from(string) 和 Buffer.concat() 创建的新 Buffer 实例的池，仅当 size 小于 Buffer.poolSize >>> 1（Buffer.poolSize 除以二的底数）。

使用此预先分配的内部内存池是调用 Buffer.alloc(size, fill) 与 Buffer.allocUnsafe(size).fill(fill) 之间的关键区别。具体来说，Buffer.alloc(size, fill) *永远不会* 使用内部 Buffer 池，而如果 size 小于或等于一半 Buffer.poolSize，则 Buffer.allocUnsafe(size).fill(fill) *将* 使用内部 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 的内容是未知的，*可能包含敏感数据*。使用 buf.fill(0) 来使用零初始化此类 Buffer 实例。

当使用 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>

返回一个新的 Buffer，它是将 list 中所有 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 是一个类数组对象（也就是说，具有 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 参数指定 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 数据复制到新的 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（十六进制）或 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#

• <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 之前、之后还是与 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（十进制），则 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> value 在 buf 中首次出现的索引，如果 buf 不包含 value，则返回 -1。

如果 value 是

• 字符串，则根据 encoding 中的字符编码解释 value。
• 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> 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

如果 value 不是字符串、数字或 Buffer，则此方法将抛出 TypeError。 如果 value 是数字，它将被强制转换为有效的字节值，即介于 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#

• <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>

从 buf 中指定的 offset 读取一个有符号的、大端序的 64 位整数。

从 Buffer 中读取的整数被解释为二进制补码有符号值。

buf.readBigInt64LE([offset])#

• offset <integer> 开始读取之前要跳过的字节数。 必须满足： 0 <= offset <= buf.length - 8。 默认值: 0。
• 返回: <bigint>

从 buf 中指定的 offset 读取一个有符号的、小端序的 64 位整数。

从 Buffer 中读取的整数被解释为二进制补码有符号值。

buf.readBigUInt64BE([offset])#

• offset <integer> 开始读取之前要跳过的字节数。 必须满足： 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 <integer> 开始读取之前要跳过的字节数。 必须满足： 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 <integer> 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= buf.length - 8。 默认值: 0。
• 返回: <number>

从 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 <integer> 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= buf.length - 8。 默认值: 0。
• 返回: <number>

从 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 <integer> 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= buf.length - 4。 默认值: 0。
• 返回: <number>

从 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 <integer> 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= buf.length - 4。 默认值: 0。
• 返回: <number>

从 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 <integer> 开始读取之前要跳过的字节数。 必须满足 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 <integer> 开始读取之前要跳过的字节数。 必须满足 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 <integer> 开始读取之前要跳过的字节数。 必须满足 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 <integer> 开始读取之前要跳过的字节数。 必须满足 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 <integer> 开始读取之前要跳过的字节数。 必须满足 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 <integer> 开始读取之前要跳过的字节数。 必须满足 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 <integer> 开始读取之前要跳过的字节数。 必须满足 0 <= offset <= buf.length - 2。 默认值: 0。
• 返回: <integer>

从 buf 中指定的 offset 读取一个无符号的、大端序的 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>

从 buf 中指定的 offset 读取一个无符号的、小端序的 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>

从 buf 中指定的 offset 读取一个无符号的、大端序的 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>

从 buf 中指定的 offset 读取一个无符号的、小端序的 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 <integer> 新 Buffer 将从哪里开始。 默认值: 0。
• end <integer> 新 Buffer 将在哪里结束（不包括）。 默认值: buf.length。
• 返回值: <Buffer>

返回一个新的 Buffer，它引用与原始 Buffer 相同的内存，但通过 start 和 end 索引进行偏移和裁剪。

指定 end 大于 buf.length 将返回与 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 <integer> 新 Buffer 将从哪里开始。 默认值: 0。
• end <integer> 新 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 位整数数组，并就地交换字节顺序。如果 ERR_INVALID_BUFFER_SIZE buf.length 不是 2 的倍数，则抛出错误。

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);

console.log(buf1);
// Prints: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap16();

console.log(buf1);
// Prints: <Buffer 02 01 04 03 06 05 08 07>

const buf2 = Buffer.from([0x1, 0x2, 0x3]);

buf2.swap16();
// Throws ERR_INVALID_BUFFER_SIZE.const { Buffer } = require('node:buffer');

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);

console.log(buf1);
// Prints: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap16();

console.log(buf1);
// Prints: <Buffer 02 01 04 03 06 05 08 07>

const buf2 = Buffer.from([0x1, 0x2, 0x3]);

buf2.swap16();
// Throws ERR_INVALID_BUFFER_SIZE.copy

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 位整数数组，并就地交换字节顺序。如果 ERR_INVALID_BUFFER_SIZE buf.length 不是 4 的倍数，则抛出错误。

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);

console.log(buf1);
// Prints: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap32();

console.log(buf1);
// Prints: <Buffer 04 03 02 01 08 07 06 05>

const buf2 = Buffer.from([0x1, 0x2, 0x3]);

buf2.swap32();
// Throws ERR_INVALID_BUFFER_SIZE.const { Buffer } = require('node:buffer');

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);

console.log(buf1);
// Prints: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap32();

console.log(buf1);
// Prints: <Buffer 04 03 02 01 08 07 06 05>

const buf2 = Buffer.from([0x1, 0x2, 0x3]);

buf2.swap32();
// Throws ERR_INVALID_BUFFER_SIZE.copy

buf.swap64()#

• 返回: <Buffer> 对 buf 的引用。

将 buf 解释为 64 位数字数组，并就地交换字节顺序。如果 ERR_INVALID_BUFFER_SIZE buf.length 不是 8 的倍数，则抛出错误。

import { Buffer } from 'node:buffer';

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);

console.log(buf1);
// Prints: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap64();

console.log(buf1);
// Prints: <Buffer 08 07 06 05 04 03 02 01>

const buf2 = Buffer.from([0x1, 0x2, 0x3]);

buf2.swap64();
// Throws ERR_INVALID_BUFFER_SIZE.const { Buffer } = require('node:buffer');

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);

console.log(buf1);
// Prints: <Buffer 01 02 03 04 05 06 07 08>

buf1.swap64();

console.log(buf1);
// Prints: <Buffer 08 07 06 05 04 03 02 01>

const buf2 = Buffer.from([0x1, 0x2, 0x3]);

buf2.swap64();
// Throws ERR_INVALID_BUFFER_SIZE.copy

buf.toJSON()#

• 返回: <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 值的迭代器（字节）。 在 for..of 语句中使用 Buffer 时，会自动调用此函数。

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 <integer> 开始写入之前要跳过的字节数。 必须满足：0 <= offset <= buf.length - 8。 默认: 0。
• 返回: <integer> 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 <integer> 开始写入之前要跳过的字节数。 必须满足：0 <= offset <= buf.length - 8。 默认: 0。
• 返回: <integer> 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 <integer> 开始写入之前要跳过的字节数。 必须满足：0 <= offset <= buf.length - 8。 默认: 0。
• 返回: <integer> 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 <integer> 开始写入之前要跳过的字节数。 必须满足：0 <= offset <= buf.length - 8。 默认: 0。
• 返回: <integer> 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 <number> 要写入 buf 的数字。
• offset <integer> 开始写入之前要跳过的字节数。 必须满足 0 <= offset <= buf.length - 8。 默认: 0。
• 返回: <integer> 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 <number> 要写入 buf 的数字。
• offset <integer> 开始写入之前要跳过的字节数。 必须满足 0 <= offset <= buf.length - 8。 默认: 0。
• 返回: <integer> 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 <number> 要写入 buf 的数字。
• offset <integer> 开始写入之前要跳过的字节数。 必须满足 0 <= offset <= buf.length - 4。 默认: 0。
• 返回: <integer> 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])#