Node.js v21.7.2 文档

缓冲区和字符编码#

在 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' 之前，另外取消设置每个字节的最高位。通常，没有理由使用此编码，因为 'utf8'（或者，如果数据已知始终为 ASCII 仅，则为 'latin1'）在编码或解码 ASCII 仅文本时将是更好的选择。它仅出于向后兼容性而提供。

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

现代 Web 浏览器遵循 WHATWG 编码标准，该标准将 'latin1' 和 'ISO-8859-1' 都别名为 'win-1252'。这意味着，在执行类似 http.get() 的操作时，如果返回的字符集是 WHATWG 规范中列出的字符集之一，则服务器实际上可能返回了 'win-1252' 编码的数据，并且使用 'latin1' 编码可能会错误地解码字符。

缓冲区和类型化数组#

Buffer 实例也是 JavaScript Uint8Array 和 TypedArray 实例。所有 TypedArray 方法都可以在 Buffer 上使用。但是，Buffer API 和 TypedArray API 之间存在细微的不兼容性。

特别是

• 虽然 TypedArray.prototype.slice() 创建了 TypedArray 部分的副本，但 Buffer.prototype.slice() 创建了对现有 Buffer 的视图，而没有进行复制。这种行为可能会令人惊讶，并且仅出于向后兼容性而存在。 TypedArray.prototype.subarray() 可用于实现 Buffer.prototype.slice() 在 Buffer 和其他 TypedArray 上的行为，并且应该优先使用。
• buf.toString() 与其 TypedArray 等效项不兼容。
• 许多方法，例如 buf.indexOf()，支持额外的参数。

有两种方法可以从 Buffer 创建新的 TypedArray 实例。

• 将 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 将创建一个与 Buffer 共享其内存的 TypedArray。

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 属性以相同的方式，创建一个与 TypedArray 实例共享相同分配内存的新 Buffer。 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，该 Promise 将使用包含 Blob 数据副本的 <ArrayBuffer> 完成。

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 将使用 Blob 的内容（以 UTF-8 字符串解码）完成。

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#

Buffer 类是一个用于直接处理二进制数据的全局类型。它可以通过多种方式构造。

静态方法：Buffer.alloc(size[, fill[, encoding]])#

• size <整数> 新 Buffer 的所需长度。
• fill <字符串> | <Buffer> | <Uint8Array> | <整数> 用于预填充新 Buffer 的值。默认值：0。
• encoding <字符串> 如果 fill 是字符串，则为其编码。默认值：'utf8'。

分配一个大小为 size 字节的新 Buffer。如果 fill 未定义，则 Buffer 将被填充为零。

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(5);

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

const buf = Buffer.alloc(5);

console.log(buf);
// Prints: <Buffer 00 00 00 00 00>copy

如果 size 大于 buffer.constants.MAX_LENGTH 或小于 0，则会抛出 ERR_OUT_OF_RANGE。

如果指定了 fill，则分配的 Buffer 将通过调用 buf.fill(fill) 初始化。

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(5, 'a');

console.log(buf);
// Prints: <Buffer 61 61 61 61 61>const { Buffer } = require('node:buffer');

const buf = Buffer.alloc(5, 'a');

console.log(buf);
// Prints: <Buffer 61 61 61 61 61>copy

如果同时指定了 fill 和 encoding，则分配的 Buffer 将通过调用 buf.fill(fill, encoding) 初始化。

import { Buffer } from 'node:buffer';

const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');

console.log(buf);
// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>const { Buffer } = require('node:buffer');

const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');

console.log(buf);
// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>copy

调用 Buffer.alloc() 可能比替代方法 Buffer.allocUnsafe() 慢，但它确保新创建的 Buffer 实例内容永远不会包含来自先前分配的敏感数据，包括可能未分配给 Buffer 的数据。

如果 size 不是数字，则会抛出 TypeError。

静态方法：Buffer.allocUnsafe(size)#

• size <整数> 新 Buffer 的所需长度。

分配一个新的 Buffer，大小为 size 字节。如果 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 除以二的向下取整）。

使用这个预先分配的内部内存池是调用 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 的所需长度。

分配一个新的 Buffer，大小为 size 字节。如果 size 大于 buffer.constants.MAX_LENGTH 或小于 0，则会抛出 ERR_OUT_OF_RANGE 错误。如果 size 为 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 <integer> view中的起始偏移量。**默认值：** 0。
• length <integer> 要复制的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 <integer[]>

使用范围在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是一个类似数组的对象（即具有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'。

创建一个包含 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.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 的内容中创建并返回一个包含 [索引, 字节] 对的 迭代器。

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#

• <整数>

返回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。
• 返回值：<number>

从指定offset处的buf读取一个 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。
• 返回值：<number>

从指定offset处的buf读取一个 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>

从指定offset处的buf读取一个 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>

从指定offset处的buf读取一个 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>

从指定offset处的buf读取一个有符号的 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>

从指定offset处的buf读取一个有符号的大端 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>

从指定offset处的buf读取一个有符号的小端 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>

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

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

从指定offset处的buf中读取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>

从指定offset处的buf中读取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>

从指定offset处的buf中读取一个无符号的8位整数。

此函数也可以在readUint8别名下使用。

import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt8(0));
// Prints: 1
console.log(buf.readUInt8(1));
// Prints: 254
console.log(buf.readUInt8(2));
// Throws ERR_OUT_OF_RANGE.const { Buffer } = require('node:buffer');

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

console.log(buf.readUInt8(0));
// Prints: 1
console.log(buf.readUInt8(1));
// Prints: 254
console.log(buf.readUInt8(2));
// Throws ERR_OUT_OF_RANGE.copy

buf.readUInt16BE([offset])#

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

从指定offset处的buf中读取一个无符号的大端16位整数。

此函数也可以在readUint16BE别名下使用。

import { Buffer } from 'node:buffer';

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

console.log(buf.readUInt16BE(0).toString(16));
// Prints: 1234
console.log(buf.readUInt16BE(1).toString(16));
// Prints: 3456const { Buffer } = require('node:buffer');

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

console.log(buf.readUInt16BE(0).toString(16));
// Prints: 1234
console.log(buf.readUInt16BE(1).toString(16));
// Prints: 3456copy

buf.readUInt16LE([offset])#

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

从 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 位整数数组，并就地交换字节顺序。如果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 <整数> 要写入的最大字节数（写入的字节数不会超过 buf.length - offset）。默认值： buf.length - offset。
• encoding <字符串> string 的字符编码。默认值： 'utf8'。
• 返回值： <整数> 写入的字节数。

根据 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 <大整数> 要写入 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 <大整数> 要写入 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 <大整数> 要写入 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 <大整数> 要写入 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 <integer> 开始写入之前要跳过的字节数。必须满足 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 <integer> 开始写入之前要跳过的字节数。必须满足 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 <integer> 要写入 buf 的数字。
• offset <integer> 开始写入之前要跳过的字节数。必须满足 0 <= offset <= buf.length - 1。默认值： 0。
• 返回值： <整数> offset 加上写入的字节数。

将 value 写入 buf 中指定的 offset 位置。value 必须是有效的有符号 8 位整数。当 value 不是有符号 8 位整数时，行为未定义。

value 被解释并写入为二进制补码有符号整数。