如果 obj 是一个 Buffer 则返回 true ，否则返回 false 。

类方法：Buffer.isEncoding(encoding)#

• encoding 一个要检查的字符编码名称
• 返回:

如果 encoding 是一个支持的字符编码则返回 true，否则返回 false 。

类属性：Buffer.poolSize#

• 默认: 8192

这是用于决定预分配的、内部 Buffer 实例池的大小的字节数。这个值可以修改。

buf[index]#

索引操作符 [index] 可用于获取或设置 buf 中指定 index 位置的八位字节。这个值指向的是单个字节，所以合法的值范围是的 0x00 至 0xFF（十六进制），或 0 至 255（十进制）。

该操作符继承自 Uint8Array，所以它对越界访问的处理与 UInt8Array 相同（也就是说，获取时返回 undefined，设置时什么也不做）。

例如：拷贝一个 ASCII 字符串到一个 Buffer，每次一个字节。

const str = 'Node.js';const buf = Buffer.allocUnsafe(str.length);for (let i = 0; i < str.length; i++) {  buf[i] = str.charCodeAt(i);}// 输出: Node.jsconsole.log(buf.toString('ascii'));

buf.buffer#

buffer 属性指向创建该 Buffer 的底层的 ArrayBuffer 对象。

const arrayBuffer = new ArrayBuffer(16);const buffer = Buffer.from(arrayBuffer);console.log(buffer.buffer === arrayBuffer);// 输出: true

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

• target | 要比较的 Buffer 或 Uint8Array。
• targetStart target 中开始对比的偏移量。默认: 0
• targetEnd target 中结束对比的偏移量（不包含）。默认: target.length
• sourceStart buf 中开始对比的偏移量。默认: 0
• sourceEnd buf 中结束对比的偏移量（不包含）。默认: buf.length
• 返回:

比较 buf 与 target，返回表明 buf 在排序上是否排在 target 之前、或之后、或相同。对比是基于各自 Buffer 实际的字节序列。

• 如果 target 与 buf 相同，则返回 0 。
• 如果 target 排在 buf 前面，则返回 1 。
• 如果 target 排在 buf 后面，则返回 -1 。

例子：

const buf1 = Buffer.from('ABC');const buf2 = Buffer.from('BCD');const buf3 = Buffer.from('ABCD');// 输出: 0console.log(buf1.compare(buf1));// 输出: -1console.log(buf1.compare(buf2));// 输出: -1console.log(buf1.compare(buf3));// 输出: 1console.log(buf2.compare(buf1));// 输出: 1console.log(buf2.compare(buf3));// 输出: [ , ,  ]// (结果相当于: [buf1, buf3, buf2])console.log([buf1, buf2, buf3].sort(Buffer.compare));

可选的 targetStart 、 targetEnd 、 sourceStart 与 sourceEnd 参数可用于分别在 target 与 buf 中限制对比在指定的范围内。

例子：

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

如果 targetStart < 0 、 sourceStart < 0 、 targetEnd > target.byteLength 或 sourceEnd > source.byteLength，则抛出 RangeError 错误。

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

• target | 要拷贝进的 Buffer 或 Uint8Array。
• targetStart target 中开始拷贝进的偏移量。默认: 0
• sourceStart buf 中开始拷贝的偏移量。默认: 0
• sourceEnd buf 中结束拷贝的偏移量（不包含）。默认: buf.length
• 返回: 被拷贝的字节数。

拷贝 buf 的一个区域的数据到 target 的一个区域，即便 target 的内存区域与 buf 的重叠。

例子：创建两个 Buffer 实例 buf1 与 buf2 ，并拷贝 buf1 中第 16 个至第 19 个字节到 buf2 第 8 个字节起。

const buf1 = Buffer.allocUnsafe(26);const buf2 = Buffer.allocUnsafe(26).fill('!');for (let i = 0; i < 26; i++) {  // 97 是 'a' 的十进制 ASCII 值  buf1[i] = i + 97;}buf1.copy(buf2, 8, 16, 20);// 输出: !!!!!!!!qrst!!!!!!!!!!!!!console.log(buf2.toString('ascii', 0, 25));

例子：创建一个 Buffer ，并拷贝同一 Buffer 中一个区域的数据到另一个重叠的区域。

const buf = Buffer.allocUnsafe(26);for (let i = 0; i < 26; i++) {  // 97 是 'a' 的十进制 ASCII 值  buf[i] = i + 97;}buf.copy(buf, 0, 4, 10);// 输出: efghijghijklmnopqrstuvwxyzconsole.log(buf.toString());

buf.entries()#

• 返回:

从 buf 的内容中，创建并返回一个 [index, byte] 形式的迭代器。

例子：记录一个 Buffer 全部的内容。

const buf = Buffer.from('buffer');// 输出://   [0, 98]//   [1, 117]//   [2, 102]//   [3, 102]//   [4, 101]//   [5, 114]for (const pair of buf.entries()) {  console.log(pair);}

buf.equals(otherBuffer)#

• otherBuffer 要比较的 Buffer 或 Uint8Array。
• 返回:

如果 buf 与 otherBuffer 具有完全相同的字节，则返回 true，否则返回 false。

例子：

const buf1 = Buffer.from('ABC');const buf2 = Buffer.from('414243', 'hex');const buf3 = Buffer.from('ABCD');// 输出: trueconsole.log(buf1.equals(buf2));// 输出: falseconsole.log(buf1.equals(buf3));

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

• value | | 用来填充 buf 的值。
• offset 开始填充 buf 前要跳过的字节数。默认: 0。
• end 结束填充 buf 的位置（不包含）。默认: buf.length。
• encoding 如果 value 是一个字符串，则这是它的字符编码。默认: 'utf8'。
• 返回: buf 的引用。

如果未指定 offset 和 end，则填充整个 buf。这个简化使得一个 Buffer 的创建与填充可以在一行内完成。

例子：用 ASCII 字符 'h' 填充 Buffer。

const b = Buffer.allocUnsafe(50).fill('h');// 输出: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhconsole.log(b.toString());

value 如果不是一个字符串或整数，则会被强行转换为 uint32 值。

如果 fill() 操作的最后一次写入的是一个多字节字符，则只有字符中适合 buf 的第一个字节会被写入。

例子：用一个两个字节的字符填充 Buffer。

// 输出: console.log(Buffer.allocUnsafe(3).fill('\u0222'));

If value contains invalid characters, it is truncated; if no validfill data remains, no filling is performed:

const buf = Buffer.allocUnsafe(5);// Prints: console.log(buf.fill('a'));// Prints: console.log(buf.fill('aazz', 'hex'));// Prints: console.log(buf.fill('zz', 'hex'));

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

• value | | 要搜索的值
• byteOffset buf 中开始搜索的位置。默认: 0
• encoding 如果 value 是一个字符串，则这是它的字符编码。默认: 'utf8'
• 返回: 如果 buf 找到 value，则返回 true，否则返回 false

相当于 buf.indexOf() !== -1。

例子：

const buf = Buffer.from('this is a buffer');// 输出: trueconsole.log(buf.includes('this'));// 输出: trueconsole.log(buf.includes('is'));// 输出: trueconsole.log(buf.includes(Buffer.from('a buffer')));// 输出: true// (97 是 'a' 的十进制 ASCII 值)console.log(buf.includes(97));// 输出: falseconsole.log(buf.includes(Buffer.from('a buffer example')));// 输出: trueconsole.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)));// 输出: falseconsole.log(buf.includes('this', 4));

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

• value | | | 要搜索的值
• byteOffset buf 中开始搜索的位置。默认: 0
• encoding 如果 value 是一个字符串，则这是它的字符编码。默认: 'utf8'
• 返回: buf 中 value 首次出现的索引，如果 buf 没包含 value 则返回 -1

如果 value 是：

• 字符串，则 value 根据 encoding 的字符编码进行解析。
• Buffer 或 Uint8Array，则 value 会被作为一个整体使用。如果要比较部分 Buffer，可使用 buf.slice()。
• 数值, 则 value 会解析为一个 0 至 255 之间的无符号八位整数值。

例子：

const buf = Buffer.from('this is a buffer');// 输出: 0console.log(buf.indexOf('this'));// 输出: 2console.log(buf.indexOf('is'));// 输出: 8console.log(buf.indexOf(Buffer.from('a buffer')));// 输出: 8// (97 是 'a' 的十进制 ASCII 值)console.log(buf.indexOf(97));// 输出: -1console.log(buf.indexOf(Buffer.from('a buffer example')));// 输出: 8console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)));const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');// 输出: 4console.log(utf16Buffer.indexOf('\u03a3', 0, 'ucs2'));// 输出: 6console.log(utf16Buffer.indexOf('\u03a3', -4, 'ucs2'));

如果 value 不是一个字符串， 数字， 或者 Buffer， 该方法会抛出一个TypeError 异常， 如果 value 是一个数字， 它将会被强制转换成一个有效的 byte 值，该值介于0到255之间。

如果 byteOffset 不是一个数字， 它将会被强制转换成一个数字。 任何对 NaN 或者 0, 像 {}, [], null or undefined，的参数， 将会搜索整个 buffer。 该行为和 String#indexOf() 保持一致。

const b = Buffer.from('abcdef');// 传入一个不是有效字节的数字// 输出：2，相当于搜索 99 或 'c'console.log(b.indexOf(99.9));console.log(b.indexOf(256 + 99));// 传入 byteOffset，其值强制转换为 NaN 或 0// 输出：1，搜索整个 bufferconsole.log(b.indexOf('b', undefined));console.log(b.indexOf('b', {}));console.log(b.indexOf('b', null));console.log(b.indexOf('b', []));

如果 value 是一个空字符串或空 Buffer，并且 byteOffset 小于 buf.length，返回 byteOffset。如果 value 是一个空字符串，并且 byteOffset 大于 buf.length，返回 buf.length。

buf.keys()#

• 返回:

创建并返回一个包含 buf 键名（索引）的迭代器。

例子：

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

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

• value | | | 要搜索的值
• byteOffset buf 中开始搜索的位置。默认: buf.length- 1
• encoding 如果 value 是一个字符串，则这是它的字符编码。默认: 'utf8'
• 返回: buf 中 value 最后一次出现的索引，如果 buf 没包含 value 则返回 -1

与 buf.indexOf() 类似，除了 buf 是从后往前搜索而不是从前往后。

例子：

const buf = Buffer.from('this buffer is a buffer');// 输出: 0console.log(buf.lastIndexOf('this'));// 输出: 17console.log(buf.lastIndexOf('buffer'));// 输出: 17console.log(buf.lastIndexOf(Buffer.from('buffer')));// 输出: 15// (97 是 'a' 的十进制 ASCII 值)console.log(buf.lastIndexOf(97));// 输出: -1console.log(buf.lastIndexOf(Buffer.from('yolo')));// 输出: 5console.log(buf.lastIndexOf('buffer', 5));// 输出: -1console.log(buf.lastIndexOf('buffer', 4));const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');// 输出: 6console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'ucs2'));// 输出: 4console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'ucs2'));

如果 value 不是一个字符串， 数字， 或者 Buffer， 该方法会抛出一个TypeError 异常， 如果 value 是一个数字， 它将会被强制转换成一个有效的 byte 值，该值介于0到255之间。

如果 byteOffset 不是一个数字， 它将会被强制转换成一个数字。 任何对 NaN or 0, like {}, [], null or undefined，的参数， 将会搜索整个 buffer。 该行为和 String#lastIndexOf() 保持一致。

const b = Buffer.from('abcdef');// 传入一个不是有效字节的数字// 输出：2，相当于搜索 99 或 'c'console.log(b.lastIndexOf(99.9));console.log(b.lastIndexOf(256 + 99));// 传入 byteOffset，其值强制转换为 NaN// 输出：1，搜索整个 bufferconsole.log(b.lastIndexOf('b', undefined));console.log(b.lastIndexOf('b', {}));// 传入 byteOffset，其值强制转换为 0// 输出：-1，相当于传入 0console.log(b.lastIndexOf('b', null));console.log(b.lastIndexOf('b', []));

如果 value 是一个空字符串或者空 Buffer，返回 byteOffset。

buf.length#

返回 buf 在字节数上分配的内存量。注意，这并不一定反映 buf 内可用的数据量。

例子：创建一个 Buffer 并写入一个较短的 ASCII 字符串。

const buf = Buffer.alloc(1234);// 输出: 1234console.log(buf.length);buf.write('some string', 0, 'ascii');// 输出: 1234console.log(buf.length);

虽然 length 属性不是不可变的，但改变 length 的值可能会导致不确定、不一致的行为。那些希望修改一个 Buffer 的长度的应用程序应当将 length 视为只读的，且使用 buf.slice() 创建一个新的 Buffer。

例子：

let buf = Buffer.allocUnsafe(10);buf.write('abcdefghj', 0, 'ascii');// 输出: 10console.log(buf.length);buf = buf.slice(0, 5);// 输出: 5console.log(buf.length);

buf.parent#

buf.parent 属性是 buf.buffer 不推荐的别名。

buf.readDoubleBE(offset[, noAssert])#

buf.readDoubleLE(offset[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - 8。
• noAssert 是否跳过 offset 检验？默认: false。
• 返回:

用指定的字节序格式（readDoubleBE() 返回大端序，readDoubleLE() 返回小端序）从 buf 中指定的 offset 读取一个64位双精度值。

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

例子：

const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);// 输出: 8.20788039913184e-304console.log(buf.readDoubleBE());// 输出: 5.447603722011605e-270console.log(buf.readDoubleLE());// 抛出异常: RangeError: Index out of rangeconsole.log(buf.readDoubleLE(1));// 警告: 读取超出 buffer 的最后一位字节！// 这会导致内存区段错误！不要这么做！console.log(buf.readDoubleLE(1, true));

buf.readFloatBE(offset[, noAssert])#

buf.readFloatLE(offset[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - 4。
• noAssert 是否跳过 offset 检验？默认: false。
• 返回:

用指定的字节序格式（readFloatBE() 返回大端序，readFloatLE() 返回小端序）从 buf 中指定的 offset 读取一个32位浮点值。

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

例子：

const buf = Buffer.from([1, 2, 3, 4]);// 输出: 2.387939260590663e-38console.log(buf.readFloatBE());// 输出: 1.539989614439558e-36console.log(buf.readFloatLE());// 抛出异常: RangeError: Index out of rangeconsole.log(buf.readFloatLE(1));// 警告: 读取超出 buffer 的最后一位字节！// 这会导致内存区段错误！不要这么做！console.log(buf.readFloatLE(1, true));

buf.readInt8(offset[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - 1。
• noAssert 是否跳过 offset 检验？默认: false。
• 返回:

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

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

从 Buffer 中读取的整数值会被解析为二进制补码值。

例子：

const buf = Buffer.from([-1, 5]);// 输出: -1console.log(buf.readInt8(0));// 输出: 5console.log(buf.readInt8(1));// 抛出异常: RangeError: Index out of rangeconsole.log(buf.readInt8(2));

buf.readInt16BE(offset[, noAssert])#

buf.readInt16LE(offset[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - 2。
• noAssert 是否跳过 offset 检验？默认: false。
• 返回:

用指定的字节序格式（readInt16BE() 返回大端序，readInt16LE() 返回小端序）从 buf 中指定的 offset 读取一个有符号的16位整数值。

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

从 Buffer 中读取的整数值会被解析为二进制补码值。

例子：

const buf = Buffer.from([0, 5]);// 输出: 5console.log(buf.readInt16BE());// 输出: 1280console.log(buf.readInt16LE());// 抛出异常: RangeError: Index out of rangeconsole.log(buf.readInt16LE(1));

buf.readInt32BE(offset[, noAssert])#

buf.readInt32LE(offset[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - 4。
• noAssert 是否跳过 offset 检验？默认: false。
• 返回:

用指定的字节序格式（readInt32BE() 返回大端序，readInt32LE() 返回小端序）从 buf 中指定的 offset 读取一个有符号的32位整数值。

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

从 Buffer 中读取的整数值会被解析为二进制补码值。

例子：

const buf = Buffer.from([0, 0, 0, 5]);// 输出: 5console.log(buf.readInt32BE());// 输出: 83886080console.log(buf.readInt32LE());// 抛出异常: RangeError: Index out of rangeconsole.log(buf.readInt32LE(1));

buf.readIntBE(offset, byteLength[, noAssert])#

buf.readIntLE(offset, byteLength[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - byteLength。
• byteLength 要读取的字节数。必须满足：0 < byteLength <= 6。
• noAssert 是否跳过 offset 和 byteLength 校验？ 默认: false。
• 返回:

从 buf 中指定的 offset 读取 byteLength 个字节，且读取的值会被解析为二进制补码值。最高支持48位精度。

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

例子：

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);// 输出: -546f87a9cbeeconsole.log(buf.readIntLE(0, 6).toString(16));// 输出: 1234567890abconsole.log(buf.readIntBE(0, 6).toString(16));// 抛出异常: RangeError: Index out of rangeconsole.log(buf.readIntBE(1, 6).toString(16));

buf.readUInt8(offset[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - 1。
• noAssert 是否跳过 offset 检验？默认: false。
• 返回:

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

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

例子：

const buf = Buffer.from([1, -2]);// 输出: 1console.log(buf.readUInt8(0));// 输出: 254console.log(buf.readUInt8(1));// 抛出异常: RangeError: Index out of rangeconsole.log(buf.readUInt8(2));

buf.readUInt16BE(offset[, noAssert])#

buf.readUInt16LE(offset[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - 2。
• noAssert 是否跳过 offset 检验？默认: false。
• 返回:

用指定的字节序格式（readUInt16BE() 返回大端序，readUInt16LE() 返回小端序）从 buf 中指定的 offset 读取一个无符号的16位整数值。

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

例子：

const buf = Buffer.from([0x12, 0x34, 0x56]);// 输出: 1234console.log(buf.readUInt16BE(0).toString(16));// 输出: 3412console.log(buf.readUInt16LE(0).toString(16));// 输出: 3456console.log(buf.readUInt16BE(1).toString(16));// 输出: 5634console.log(buf.readUInt16LE(1).toString(16));// 抛出异常: RangeError: Index out of rangeconsole.log(buf.readUInt16LE(2).toString(16));

buf.readUInt32BE(offset[, noAssert])#

buf.readUInt32LE(offset[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - 4。
• noAssert 是否跳过 offset 检验？默认: false。
• 返回:

用指定的字节序格式（readUInt32BE() 返回大端序，readUInt32LE() 返回小端序）从 buf 中指定的 offset 读取一个无符号的32位整数值。

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

例子：

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78]);// 输出: 12345678console.log(buf.readUInt32BE(0).toString(16));// 输出: 78563412console.log(buf.readUInt32LE(0).toString(16));// 抛出异常: RangeError: Index out of rangeconsole.log(buf.readUInt32LE(1).toString(16));

buf.readUIntBE(offset, byteLength[, noAssert])#

buf.readUIntLE(offset, byteLength[, noAssert])#

• offset 开始读取前要跳过的字节数，必须满足：0 <= offset <= buf.length - byteLength。
• byteLength 要读取的字节数。必须满足：0 < byteLength <= 6。
• noAssert 是否跳过 offset 和 byteLength 校验？ 默认: false。
• 返回:

从 buf 中指定的 offset 读取 byteLength 个字节，且读取的值会被解析为无符号的整数。最高支持48位精度。

设置 noAssert 为 true 则 offset 可超出 buf 的最后一位字节，但后果是不确定的。

例子：

const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab]);// 输出: 1234567890abconsole.log(buf.readUIntBE(0, 6).toString(16));// 输出: ab9078563412console.log(buf.readUIntLE(0, 6).toString(16));//抛出异常: RangeError: Index out of rangeconsole.log(buf.readUIntBE(1, 6).toString(16));

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

• start 新建的 Buffer 开始的位置。 默认: 0
• end 新建的 Buffer 结束的位置（不包含）。默认: buf.length
• 返回:

返回一个指向相同原始内存的新建的 Buffer，但做了偏移且通过 start 和 end 索引进行裁剪。

指定大于buf.length的结束值，与结束值设置为buf.length的结果一样。

注意，修改这个新建的 Buffer 切片，也会同时修改原始的 Buffer 的内存，因为这两个对象所分配的内存是重叠的。

例子：创建一个包含 ASCII 字母表的 Buffer，并进行切片，然后修改原始 Buffer 上的一个字节。

const buf1 = Buffer.allocUnsafe(26);for (let i = 0; i < 26; i++) {  // 97 是 'a' 的十进制 ASCII 值   buf1[i] = i + 97;}const buf2 = buf1.slice(0, 3);// 输出: abcconsole.log(buf2.toString('ascii', 0, buf2.length));buf1[0] = 33;// 输出: !bcconsole.log(buf2.toString('ascii', 0, buf2.length));

指定负的索引会导致切片的生成是相对于 buf 的末尾而不是开头。

例子：

const buf = Buffer.from('buffer');// 输出: buffe// (相当于 buf.slice(0, 5))console.log(buf.slice(-6, -1).toString());// 输出: buff// (相当于 buf.slice(0, 4))console.log(buf.slice(-6, -2).toString());// 输出: uff// (相当于 buf.slice(1, 4))console.log(buf.slice(-5, -2).toString());

buf.swap16()#

• 返回: buf 的引用

将 buf 解析为一个无符号16位的整数数组，并且以字节顺序原地进行交换。如果 buf.length 不是2的倍数，则抛出 RangeError 错误。

例子：

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);// 输出: console.log(buf1);buf1.swap16();// 输出: console.log(buf1);const buf2 = Buffer.from([0x1, 0x2, 0x3]);// 抛出异常: RangeError: Buffer size must be a multiple of 16-bitsbuf2.swap16();

buf.swap32()#

• 返回: buf 的引用

将 buf 解析为一个无符号32位的整数数组，并且以字节顺序原地进行交换。如果 buf.length 不是4的倍数，则抛出 RangeError 错误。

例子：

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);// 输出: console.log(buf1);buf1.swap32();// 输出: console.log(buf1);const buf2 = Buffer.from([0x1, 0x2, 0x3]);// 抛出异常: RangeError: Buffer size must be a multiple of 32-bitsbuf2.swap32();

buf.swap64()#

• 返回: buf 的引用

将 buf 解析为一个64位的数值数组，并且以字节顺序原地进行交换。如果 buf.length 不是8的倍数，则抛出 RangeError 错误。

例子：

const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);// 输出: console.log(buf1);buf1.swap64();// 输出: console.log(buf1);const buf2 = Buffer.from([0x1, 0x2, 0x3]);// 抛出异常: RangeError: Buffer size must be a multiple of 64-bitsbuf2.swap64();

注意，JavaScript 不能编码64位整数。该方法是用来处理64位浮点数的。

buf.toJSON()#

• 返回: