Buffer类

类相关的方法和属性

实例相关的方法和属性

Buffer 类是一个全局变量类型，用来直接处理2进制数据的。 它能够使用多种方式构建。

new Buffer(size)

  • size {Number}

分配一个 size 字节大小的新 Buffer。size 必须小于等于 require('buffer').kMaxLength（在64位架构上 kMaxLength 的大小是 (2^31)-1）的值，否则将抛出一个 RangeError 的错误。如果 size 小于 0 将创建一个特定的 0 长度（zero-length ）的 Buffer。

不像 ArrayBuffers ，以这种方式创建的 Buffer 实例的底层内存是没被初始化过的。新创建的 Buffer 的内容是未知的，并可能包含敏感数据。通过使用 buf.fill(0) 将一个 Buffer 初始化为零。

  1. const buf = new Buffer(5);
  2. console.log(buf);
  3. // <Buffer 78 e0 82 02 01>
  4. // (octets will be different, every time)
  5. buf.fill(0);
  6. console.log(buf);
  7. // <Buffer 00 00 00 00 00>

new Buffer(array)

  • array {Array}

分配 8 位字节大小的 array 的一个新的 Buffer 。

  1. const buf = new Buffer([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
  2. // creates a new Buffer containing ASCII bytes
  3. // ['b','u','f','f','e','r']

new Buffer(buffer)

  • buffer {Buffer}

将所传的 buffer 数据拷贝到新建的 Buffer 实例中。

  1. const buf1 = new Buffer('buffer');
  2. const buf2 = new Buffer(buf1);
  4. buf1[0] = 0x61;
  5. console.log(buf1.toString());
  6. // 'auffer'
  7. console.log(buf2.toString());
  8. // 'buffer' (copy is not changed)

new Buffer(arrayBuffer[, byteOffset[, length]])

  • arrayBuffer - 一个 arrayBuffer 或 new ArrayBuffer() 的 .buffer 属性

  • byteOffset {Number} 默认：0

  • length {Number} 默认：arrayBuffer.length - byteOffset

当传递的是 TypedArray 实例的 .buffer 引用时，这个新建的 Buffer 将像 TypedArray 那样共享相同的内存分配。

选填的 byteOffset 和 length 参数指定一个将由 Buffer 共享的 arrayBuffer 中的内存范围。

  1. const arr = new Uint16Array(2);
  2. arr[0] = 5000;
  3. arr[1] = 4000;
  5. const buf = new Buffer(arr.buffer); // shares the memory with arr;
  7. console.log(buf);
  8. // Prints: <Buffer 88 13 a0 0f>
  10. // changing the TypdArray changes the Buffer also
  11. arr[1] = 6000;
  13. console.log(buf);
  14. // Prints: <Buffer 88 13 70 17>

new Buffer(str[, encoding])

  • str {String} 需要编码的字符串

  • encoding {String} 默认：'utf8'

创建一个新的 Buffer 包含给定的 JavaScript 字符串 str。如果提供 encoding 参数，将标识字符串的字符编码。

  1. const buf1 = new Buffer('this is a tést');
  2. console.log(buf1.toString());
  3. // prints: this is a tést
  4. console.log(buf1.toString('ascii'));
  5. // prints: this is a tC)st
  7. const buf2 = new Buffer('7468697320697320612074c3a97374', 'hex');
  8. console.log(buf2.toString());
  9. // prints: this is a tést

Buffer.byteLength(string[, encoding])

  • string {String} | {Buffer} | {TypedArray} | {DataView} | {ArrayBuffer}

  • encoding {String} 默认：'utf8'

  • 返回：{Number}

返回一个字符串的实际字节长度。这与 String.prototype.length 不同，因为它是返回字符串中的字符数目。

例如：

  1. const str = '\u00bd + \u00bc = \u00be';
  3. console.log(`${str}: ${str.length} characters, ` +
  4.             `${Buffer.byteLength(str, 'utf8')} bytes`);
  6. // ½ + ¼ = ¾: 9 characters, 12 bytes

当 string 是一个 Buffer / DataView / TypedArray / ArrayBuffer 时，返回实际的字节长度。

除此之外，将转换为 String 并返回字符串的字节长度。

Buffer.isBuffer(obj)

  • obj {Object}

  • 返回：{Boolean}

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

Buffer.isEncoding(encoding)

  • encoding {String} 需要测试的编码字符串

  • 返回：{Boolean}

如果 encoding 是一个有效的编码参数则返回 true，否则返回 false。

Buffer.from(array)

  • array {Array}

使用一个8位字节的数组分配一个新的 Buffer。

  1. const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
  2. // creates a new Buffer containing ASCII bytes
  3. // ['b','u','f','f','e','r']

如果 array 不是一个有效的 Array 则抛出一个 TypeError 错误。

Buffer.from(buffer)

  • buffer {Buffer}

将所传的 buffer 数据拷贝到这个新的 Buffer 实例中。

  1. const buf1 = Buffer.from('buffer');
  2. const buf2 = Buffer.from(buf1);
  4. buf1[0] = 0x61;
  5. console.log(buf1.toString());
  6. // 'auffer'
  7. console.log(buf2.toString());
  8. // 'buffer' (copy is not changed)

如果 buffer 不是一个有效的 Buffer 则抛出一个 TypeError 错误。

Buffer.from(arrayBuffer[, byteOffset[, length]])

  • arrayBuffer - 一个 TypedArray 或 new ArrayBuffer() 的 .buffer 属性

  • byteOffset {Number} 默认：0

  • length {Number} 默认：arrayBuffer.length - byteOffset

当传递的是 TypedArray 实例的 .buffer 引用时，这个新建的 Buffer 将像 TypedArray 那样共享相同的内存分配。

  1. const arr = new Uint16Array(2);
  2. arr[0] = 5000;
  3. arr[1] = 4000;
  5. const buf = Buffer.from(arr.buffer); // shares the memory with arr;
  7. console.log(buf);
  8. // Prints: <Buffer 88 13 a0 0f>
  10. // changing the TypedArray changes the Buffer also
  11. arr[1] = 6000;
  13. console.log(buf);
  14. // Prints: <Buffer 88 13 70 17>

选填的 byteOffset 和 length 参数指定一个将由 Buffer 共享的 arrayBuffer 中的内存范围。

  1. const ab = new ArrayBuffer(10);
  2. const buf = Buffer.from(ab, 0, 2);
  3. console.log(buf.length);
  4. // Prints: 2

如果 arrayBuffer 不是一个有效的 ArrayBuffer 则抛出一个 TypeError 错误。

Buffer.from(str[, encoding])

  • str {String} 需要编码的字符串

  • encoding {String} 编码时用到，默认：'utf8'

创建一个新的 Buffer 包含给定的 JavaScript 字符串 str。如果提供 encoding 参数，将标识字符串的字符编码。如果没有提供 encoding 参数，默认为 'utf8'。

  1. const buf1 = Buffer.from('this is a tést');
  2. console.log(buf1.toString());
  3. // prints: this is a tést
  4. console.log(buf1.toString('ascii'));
  5. // prints: this is a tC)st
  7. const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
  8. console.log(buf2.toString());
  9. // prints: this is a tést

如果 str 不是一个有效的 String 则抛出一个 TypeError 错误。

Buffer.alloc(size[, fill[, encoding]])

  • size {Number}

  • fill {Value} 默认：undefined

  • encoding {String} 默认：utf8

分配一个 size 字节大小的新 Buffer。如果 fill 是 undefined ，该 Buffer 将被零填充（zero-filled）。

  1. const buf = Buffer.alloc(5);
  2. console.log(buf);
  3. // <Buffer 00 00 00 00 00>

size 必须小于等于 require('buffer').kMaxLength（在64位架构上 kMaxLength 的大小是 (2^31)-1）的值，否则将抛出一个 RangeError 的错误。如果 size 小于 0 将创建一个特定的 0 长度（zero-length ）的 Buffer。

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

  1. const buf = Buffer.alloc(5, 'a');
  2. console.log(buf);
  3. // <Buffer 61 61 61 61 61>

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

  1. const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
  2. console.log(buf);
  3. // <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>

调用 Buffer.alloc(size) 方法显然要比替代的 Buffer.allocUnsafe(size) 要慢，但可以确保新建的 Buffer 实例的内容不会包含敏感数据。

如果 size 不是一个数字则抛出一个 TypeError 错误。

Buffer.allocUnsafe(size)

  • size {Number}

分配一个 size 字节大小的新的非零填充（non-zero-filled）的 Buffer。size 必须小于等于 require('buffer').kMaxLength（在64位架构上 kMaxLength 的大小是 (2^31)-1）的值，否则将抛出一个 RangeError 的错误。如果 size 小于 0 将创建一个特定的 0 长度（zero-length ）的 Buffer。

以这种方式创建的 Buffer 实例的底层内存是没被初始化过的。新创建的 Buffer 的内容是未知的，并可能包含敏感数据。通过使用 buf.fill(0) 将这个 Buffer 初始化为零。

  1. const buf = Buffer.allocUnsafe(5);
  2. console.log(buf);
  3. // <Buffer 78 e0 82 02 01>
  4. // (octets will be different, every time)
  5. buf.fill(0);
  6. console.log(buf);
  7. // <Buffer 00 00 00 00 00>

如果 size 不是一个数字则抛出一个 TypeError 错误。

请注意，Buffer 模块预分配一个大小为 Buffer.poolSize 的内部 Buffer 实例作为一个快速分配池，仅当 size 小于等于 Buffer.poolSize >> 1 （浮点类型的 Buffer.poolSize 应该除以2）时，用于分配通过 Buffer.allocUnsafe(size) 创建的新的 Buffer 实例（和 new Buffer(size) 构造函数）。默认的 Buffer.poolSize 值为 8192 ，但可以被修改。

使用这个预分配的内部内存池是调用 Buffer.alloc(size, fill) 和 Buffer.allocUnsafe(size).fill(fill) 的关键不同之处。特别是，如果 size 小于或等于 Buffer.poolSize 的一半时，Buffer.allocUnsafe(size).fill(fill) 将使用内部的 Buffer 池，而 Buffer.alloc(size, fill) 将绝不会使用这个内部的 Buffer 池。在一个应用程序需要 Buffer.allocUnsafe(size) 提供额外的性能时，（了解）这个细微的不同之处是非常重要的。

Buffer.concat(list[, totalLength])

  • list {Array} 需要连接的 Buffer 对象数组

  • totalLength {Number} 上述需要被连接的 Buffer 的总大小。

  • 返回：{Buffer}

返回一个连接了 list 中所有 Buffer 的新 Buffer 。

如果 list 中没有项目，或者当 totalLength 为 0 时，将返回一个 0 长度（zero-length）的 Buffer 。

如果没有提供 totalLength ，它将计算 list 中的 Buffer（以获得该值）。然而，这增加了额外的函数循环，提供精准的长度将加速计算。

例如：将一个包含三个 Buffer 的数组构建为一个单一的 Buffer ：

  1. const buf1 = Buffer.alloc(10, 0);
  2. const buf2 = Buffer.alloc(14, 0);
  3. const buf3 = Buffer.alloc(18, 0);
  4. const totalLength = buf1.length + buf2.length + buf3.length;
  6. console.log(totalLength);
  7. const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
  8. console.log(bufA);
  9. console.log(bufA.length);
  11. // 42
  12. // <Buffer 00 00 00 00 ... >
  13. // 42

Buffer.compare(buf1, buf2)

  • buf1 {Buffer}

  • buf2 {Buffer}

  • 返回：{Number}

比较 buf1 和 buf2 通常用于 Buffer 数组的排序目的。这相当于是调用 buf1.compare(buf2) 。

  1. const arr = [Buffer.from('1234'), Buffer.from('0123')];
  2. arr.sort(Buffer.compare);

实例的属性和方法

buf.length

  • {Number}

返回该 Buffer 在字节数上分配的内存量。注意，这并不一定反映 Buffer 内可用的数据量。例如在下面的例子中，一个 Buffer 分配了 1234 字节，但只写入了 11 ASCII 字节。

  1. const buf = Buffer.allocUnsafe(1234);
  3. console.log(buf.length);
  4. // Prints: 1234
  6. buf.write('some string', 0, 'ascii');
  7. console.log(buf.length);
  8. // Prints: 1234

而 length 属性并非一成不变，改变 length 值会导致不确定和不一致的行为。应用程序如果希望修改一个 Buffer 的长度，因而需要把 length 设为只读并使用 buf.slice() 创建一个新的 Buffer 。

  1. var buf = Buffer.allocUnsafe(10);
  2. buf.write('abcdefghj', 0, 'ascii');
  3. console.log(buf.length);
  4. // Prints: 10
  5. buf = buf.slice(0, 5);
  6. console.log(buf.length);
  7. // Prints: 5

buf[index]

索引操作符 [index] 可用于获取或设置 Buffer 中指定 index 位置的8位字节。这个值指的是单个字节，所以这个值合法范围是16进制的 0x00 到 0xFF，或 10进制的 0 到 255。

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

  1. const str = "Node.js";
  2. const buf = Buffer.allocUnsafe(str.length);
  4. for (var i = 0; i < str.length; i++) {
  5.     buf[i] = str.charCodeAt(i);
  6. }
  8. console.log(buf.toString('ascii'));
  9. // Prints: Node.js

buf.toString([encoding[, start[, end]]])

  • encoding {String} 默认：'utf8'

  • start {Number} 默认：0

  • end {Number} 默认：buffer.length

  • 返回：{String}

返回使用指定的字符集编码解码 Buffer 数据的字符串。

  1. const buf = Buffer.allocUnsafe(26);
  2. for (var i = 0; i < 26; i++) {
  3.     buf[i] = i + 97; // 97 is ASCII a
  4. }
  5. buf.toString('ascii');
  6. // Returns: 'abcdefghijklmnopqrstuvwxyz'
  7. buf.toString('ascii', 0, 5);
  8. // Returns: 'abcde'
  9. buf.toString('utf8', 0, 5);
  10. // Returns: 'abcde'
  11. buf.toString(undefined, 0, 5);
  12. // Returns: 'abcde', encoding defaults to 'utf8'

buf.toJSON()

  • 返回：{Object}

返回该 Buffer 实例的 JSON 表达式。当字符串化一个 Buffer 实例时会隐式调用 JSON.stringify() 这个函数。

例子：

  1. const buf = Buffer.from('test');
  2. const json = JSON.stringify(buf);
  4. console.log(json);
  5. // Prints: '{"type":"Buffer","data":[116,101,115,116]}'
  7. const copy = JSON.parse(json, (key, value) => {
  8.     return value && value.type === 'Buffer' ? Buffer.from(value.data) : value;
  9. });
  11. console.log(copy.toString());
  12. // Prints: 'test'

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

  • start {Number} 默认：0

  • end {Number} 默认：buffer.length

  • 返回：{Buffer}

返回一个指向相同原始内存的新 Buffer ，但会有偏移并通过 start 和 end 索引值进行裁剪。

请注意，修改这个新的 Buffer 切片，将会修改原始 Buffer 的内存，因为这两个对象共享所分配的内存。

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

  1. const buf1 = Buffer.allocUnsafe(26);
  3. for (var i = 0; i < 26; i++) {
  4.     buf1[i] = i + 97; // 97 is ASCII a
  5. }
  7. const buf2 = buf1.slice(0, 3);
  8. buf2.toString('ascii', 0, buf2.length);
  9. // Returns: 'abc'
  10. buf1[0] = 33;
  11. buf2.toString('ascii', 0, buf2.length);
  12. // Returns : '!bc'

指定负索引会导致产生相对于这个 Buffer 的末尾而不是开头的切片（slice）。

  1. const buf = Buffer.from('buffer');
  3. buf.slice(-6, -1).toString();
  4. // Returns 'buffe', equivalent to buf.slice(0, 5)
  5. buf.slice(-6, -2).toString();
  6. // Returns 'buff', equivalent to buf.slice(0, 4)
  7. buf.slice(-5, -2).toString();
  8. // Returns 'uff', equivalent to buf.slice(1, 4)

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

  • value {String} | {Buffer} | {Number}

  • offset {Number} 默认：0

  • end {Number} 默认：buf.length

  • encoding {String} 默认：'utf8'

  • 返回：{Buffer}

使用指定的值填充当前 Buffer 。如果 offset (默认是 0) 和 end (默认是 buffer.length) 没有明确给出，将会填充整个 buffer 。该方法返回一个当前 Buffer 的引用，以便于链式调用。这也意味着可以通过这种小而简的方式创建一个 Buffer 。允许在单行内创建和填充 Buffer ：

  1. const b = Buffer.alloc(50, 'h');
  2. console.log(b.toString());
  3. // Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

encoding 只在 value 是一个字符串时应用，除此之外，都会被忽略。如果 value 不是一个 String 或 Number ，则会被强制转换到 uint32 类型。

fill() 操作默默地向 Buffer 里写入字节。即便最终写入落在多字节字符之间，它也会将这些字节塞到被写入的 buffer 里。

  1. Buffer.alloc(3, '\u0222');
  2. // Prints: <Buffer c8 a2 c8>

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

  • value {String} | {Buffer} | {Number}

  • byteOffset {Number} 默认：0

  • encoding {String} 默认：'utf8'

  • 返回：{Number}

该操作类似于 Array#indexOf() ，它返回 value 在 Buffer 中的最开始的索引位置，如果当前 Buffer 不包含这个 value 则返回 -1 。这个 value 的值可以是 String 、Buffer 或 Number 。字符串会默认用 UTF8 解释执行。Buffer 将会使用整个 Buffer（比较部分 Buffer 请使用 buf.slice() 方法）。数字在 0 到 255 的范围内。 

  1. const buf = Buffer.from('this is a buffer');
  3. buf.indexOf('this');
  4. // returns 0
  5. buf.indexOf('is');
  6. // returns 2
  7. buf.indexOf(Buffer.from('a buffer'));
  8. // returns 8
  9. buf.indexOf(97); // ascii for 'a'
  10. // returns 8
  11. buf.indexOf(Buffer.from('a buffer example'));
  12. // returns -1
  13. buf.indexOf(Buffer.from('a buffer example').slice(0, 8));
  14. // returns 8
  16. const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'ucs2');
  18. utf16Buffer.indexOf('\u03a3', 0, 'ucs2');
  19. // returns 4
  20. utf16Buffer.indexOf('\u03a3', -4, 'ucs2');
  21. // returns 6

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

  • value {String} | {Buffer} | {Number}

  • byteOffset {Number} 默认：0

  • encoding {String} 默认：'utf8'

  • 返回：{Boolean}

该操作类似于 Array#includes()。这个 value 的值可以是 String 、Buffer 或 Number 。字符串会被作为 UTF8 解释执行，除非你覆盖了 encoding 参数。Buffer 将会使用整个 Buffer（比较部分 Buffer 请使用 buf.slice() 方法）。数字在 0 到 255 的范围内。

byteOffset 表示在搜索 buf 时的初始索引值。

  1. const buf = Buffer.from('this is a buffer');
  3. buf.includes('this');
  4. // returns true
  5. buf.includes('is');
  6. // returns true
  7. buf.includes(Buffer.from('a buffer'));
  8. // returns true
  9. buf.includes(97); // ascii for 'a'
  10. // returns true
  11. buf.includes(Buffer.from('a buffer example'));
  12. // returns false
  13. buf.includes(Buffer.from('a buffer example').slice(0, 8));
  14. // returns true
  15. buf.includes('this', 4);
  16. // returns false

buf.copy(targetBuffer[, targetStart[, sourceStart[, sourceEnd]]])

  • targetBuffer {Buffer} 需要拷贝的 Buffer

  • targetStart {Number} 默认：0

  • sourceStart {Number} 默认：0

  • sourceEnd {Number} 默认：buffer.length

  • 返回：{Number} 被拷贝的字节数

将这个 Buffer 的一个区域的数据拷贝到目标 Buffer 的一个区域，即便与目标是共享内存区域资源的。

例子：创建两个 Buffer ，然后把将 buf1 第 16 到 19 位的字节拷贝到 buf2 中，并从 buf2 的第 8 位开始（覆盖）。

  1. const buf1 = Buffer.allocUnsafe(26);
  2. const buf2 = Buffer.allocUnsafe(26).fill('!');
  4. for (var i = 0; i < 26; i++) {
  5.     buf1[i] = i + 97; // 97 is ASCII a
  6. }
  8. buf1.copy(buf2, 8, 16, 20);
  9. console.log(buf2.toString('ascii', 0, 25));
  10. // Prints: !!!!!!!!qrst!!!!!!!!!!!!!

例子：创建一个单一的 Buffer ，然后将一块区域的数据拷贝到同一个 Buffer 中另一块交叉的区域。

  1. const buf = Buffer.allocUnsafe(26);
  3. for (var i = 0; i < 26; i++) {
  4.     buf[i] = i + 97; // 97 is ASCII a
  5. }
  7. buf.copy(buf, 0, 4, 10);
  8. console.log(buf.toString());
  10. // efghijghijklmnopqrstuvwxyz

buf.compare(otherBuffer)

  • otherBuffer {Buffer}

  • 返回：{Number}

比较两个 Buffer 实例，无论 buf 在排序上靠前、靠后甚至与 otherBuffer 相同都会返回一个数字标识。比较是基于在每个 Buffer 的实际字节序列。

  • 如果 otherBuffer 和 buf 相同，则返回 0

  • 如果 otherBuffer 排在 buf 前面，则返回 1

  • 如果 otherBuffer 排在 buf 后面，则返回 -1

  1. const buf1 = Buffer.from('ABC');
  2. const buf2 = Buffer.from('BCD');
  3. const buf3 = Buffer.from('ABCD');
  5. console.log(buf1.compare(buf1));
  6. // Prints: 0
  7. console.log(buf1.compare(buf2));
  8. // Prints: -1
  9. console.log(buf1.compare(buf3));
  10. // Prints: 1
  11. console.log(buf2.compare(buf1));
  12. // Prints: 1
  13. console.log(buf2.compare(buf3));
  14. // Prints: 1
  16. [buf1, buf2, buf3].sort(Buffer.compare);
  17. // produces sort order [buf1, buf3, buf2]

buf.equals(otherBuffer)

  • otherBuffer {Buffer}

  • 返回：{Boolean}

返回一个 boolean 标识，无论 this 和 otherBuffer 是否具有完全相同的字节。

  1. const buf1 = Buffer.from('ABC');
  2. const buf2 = Buffer.from('414243', 'hex');
  3. const buf3 = Buffer.from('ABCD');
  5. console.log(buf1.equals(buf2));
  6. // Prints: true
  7. console.log(buf1.equals(buf3));
  8. // Prints: false

buf.entries()

  • 返回：{Iterator}

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

  1. const buf = Buffer.from('buffer');
  2. for (var pair of buf.entries()) {
  3.     console.log(pair);
  4. }
  5. // prints:
  6. //   [0, 98]
  7. //   [1, 117]
  8. //   [2, 102]
  9. //   [3, 102]
  10. //   [4, 101]
  11. //   [5, 114]

buf.keys()

  • 返回：{Iterator}

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

  1. const buf = Buffer.from('buffer');
  2. for (var key of buf.keys()) {
  3.     console.log(key);
  4. }
  5. // prints:
  6. //   0
  7. //   1
  8. //   2
  9. //   3
  10. //   4
  11. //   5

buf.values()

  • 返回：{Iterator}

创建并返回一个包含 Buffer 值（字节）的迭代器。当 Buffer 使用 for..of 声明时将自动调用该函数。

  1. const buf = Buffer.from('buffer');
  2. for (var value of buf.values()) {
  3.     console.log(value);
  4. }
  5. // prints:
  6. //   98
  7. //   117
  8. //   102
  9. //   102
  10. //   101
  11. //   114
  13. for (var value of buf) {
  14.     console.log(value);
  15. }
  16. // prints:
  17. //   98
  18. //   117
  19. //   102
  20. //   102
  21. //   101
  22. //   114

buf.swap16()

  • 返回：{Buffer}

将 Buffer 解释执行为一个16位的无符号整数数组并以字节顺序交换到位。如果 Buffer 的长度不是16位的倍数，则抛出一个 RangeError 错误。该方法返回一个当前 Buffer 的引用，以便于链式调用。

  1. const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
  2. console.log(buf);
  3. // Prints Buffer(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8)
  4. buf.swap16();
  5. console.log(buf);
  6. // Prints Buffer(0x2, 0x1, 0x4, 0x3, 0x6, 0x5, 0x8, 0x7)

buf.swap32()

  • 返回：{Buffer}

将 Buffer 解释执行为一个32位的无符号整数数组并以字节顺序交换到位。如果 Buffer 的长度不是32位的倍数，则抛出一个 RangeError 错误。该方法返回一个当前 Buffer 的引用，以便于链式调用。

  1. const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8]);
  2. console.log(buf);
  3. // Prints Buffer(0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8)
  4. buf.swap32();
  5. console.log(buf);
  6. // Prints Buffer(0x4, 0x3, 0x2, 0x1, 0x8, 0x7, 0x6, 0x5)

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

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

  • offset {Number} 0 <= offset <= buf.length - byteLength

  • byteLength {Number} 0 < byteLength <= 6

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的 offset 位置开始读取 byteLength 字节数，并将结果解释执行为一个有符号的2的补码值。支持多达48位精度的值。例如：

  1. const buf = Buffer.allocUnsafe(6);
  2. buf.writeUInt16LE(0x90ab, 0);
  3. buf.writeUInt32LE(0x12345678, 2);
  4. buf.readIntLE(0, 6).toString(16); // Specify 6 bytes (48 bits)
  5. // Returns: '1234567890ab'
  7. buf.readIntBE(0, 6).toString(16);
  8. // Returns: -546f87a9cbee

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

buf.readFloatBE(offset[, noAssert])

buf.readFloatLE(offset[, noAssert])

  • offset {Number} 0 <= offset <= buf.length - 4

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的带有特定尾数格式（readFloatBE() 返回一个较大的尾数，readFloatLE() 返回一个较小的尾数）的 offset 位置开始读取一个32位浮点值。

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

  1. const buf = Buffer.from([1, 2, 3, 4]);
  3. buf.readFloatBE();
  4. // Returns: 2.387939260590663e-38
  5. buf.readFloatLE();
  6. // Returns: 1.539989614439558e-36
  7. buf.readFloatLE(1);
  8. // throws RangeError: Index out of range
  10. buf.readFloatLE(1, true); // Warning: reads passed end of buffer!
  11. // Segmentation fault! don't do this!

buf.readDoubleBE(offset[, noAssert])

buf.readDoubleLE(offset[, noAssert])

  • offset {Number} 0 <= offset <= buf.length - 8

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的带有特定尾数格式（readDoubleBE() 返回一个较大的尾数，readDoubleLE() 返回一个较小的尾数）的 offset 位置开始读取一个64位双精度值。

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

  1. const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8]);
  3. buf.readDoubleBE();
  4. // Returns: 8.20788039913184e-304
  5. buf.readDoubleLE();
  6. // Returns: 5.447603722011605e-270
  7. buf.readDoubleLE(1);
  8. // throws RangeError: Index out of range
  10. buf.readDoubleLE(1, true); // Warning: reads passed end of buffer!
  11. // Segmentation fault! don't do this!

buf.readInt8(offset[, noAssert])

  • offset {Number} 0 <= offset <= buf.length - 1

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的 offset 位置开始读取一个有符号的8位整数值。

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

从 Buffer 里读取的整数数值会被解释执行为有符号的2的补码值。

  1. const buf = Buffer.from([1, -2, 3, 4]);
  3. buf.readInt8(0);
  4. // returns 1
  5. buf.readInt8(1);
  6. // returns -2

buf.readInt16BE(offset[, noAssert])

buf.readInt16LE(offset[, noAssert])

  • offset {Number} 0 <= offset <= buf.length - 2

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的带有特定尾数格式（readInt16BE() 返回一个较大的尾数，readInt16LE() 返回一个较小的尾数）的 offset 位置开始读取一个16位整数值。

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

从 Buffer 里读取的整数数值会被解释执行为有符号的2的补码值。

  1. const buf = Buffer.from([1, -2, 3, 4]);
  3. buf.readInt16BE();
  4. // returns 510
  5. buf.readInt16LE(1);
  6. // returns 1022

buf.readInt32BE(offset[, noAssert])

buf.readInt32LE(offset[, noAssert])

  • offset {Number} 0 <= offset <= buf.length - 4

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的带有特定尾数格式（readInt32BE() 返回一个较大的尾数，readInt32LE() 返回一个较小的尾数）的 offset 位置开始读取一个有符号的32位整数值。

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

从 Buffer 里读取的整数数值会被解释执行为有符号的2的补码值。

  1. const buf = Buffer.from([1, -2, 3, 4]);
  3. buf.readInt32BE();
  4. // returns 33424132
  5. buf.readInt32LE();
  6. // returns 67370497
  7. buf.readInt32LE(1);
  8. // throws RangeError: Index out of range

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

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

  • offset {Number} 0 <= offset <= buf.length - byteLength

  • byteLength {Number} 0 < byteLength <= 6

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的 offset 位置开始读取 byteLength 字节数，并将结果解释执行为一个无符号的整数值。支持多达48位精度的值。例如：

  1. const buf = Buffer.allocUnsafe(6);
  2. buf.writeUInt16LE(0x90ab, 0);
  3. buf.writeUInt32LE(0x12345678, 2);
  4. buf.readUIntLE(0, 6).toString(16); // Specify 6 bytes (48 bits)
  5. // Returns: '1234567890ab'
  7. buf.readUIntBE(0, 6).toString(16);
  8. // Returns: ab9078563412

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

buf.readUInt8(offset[, noAssert])

  • offset {Number} 0 <= offset <= buf.length - 1

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的 offset 位置开始读取一个无符号的8位整数值。

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

  1. const buf = Buffer.from([1, -2, 3, 4]);
  3. buf.readUInt8(0);
  4. // returns 1
  5. buf.readUInt8(1);
  6. // returns 254

buf.readUInt16BE(offset[, noAssert])

buf.readUInt16LE(offset[, noAssert])

  • offset {Number} 0 <= offset <= buf.length - 2

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的带有特定尾数格式（readUInt16BE() 返回一个较大的尾数，readUInt16LE() 返回一个较小的尾数）的 offset 位置开始读取一个无符号的16位整数值。

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

例子：

  1. const buf = Buffer.from([0x3, 0x4, 0x23, 0x42]);
  3. buf.readUInt16BE(0);
  4. // Returns: 0x0304
  5. buf.readUInt16LE(0);
  6. // Returns: 0x0403
  7. buf.readUInt16BE(1);
  8. // Returns: 0x0423
  9. buf.readUInt16LE(1);
  10. // Returns: 0x2304
  11. buf.readUInt16BE(2);
  12. // Returns: 0x2342
  13. buf.readUInt16LE(2);
  14. // Returns: 0x4223

buf.readUInt32BE(offset[, noAssert])

buf.readUInt32LE(offset[, noAssert])

  • offset {Number} 0 <= offset <= buf.length - 4

  • noAssert {Boolean} 默认：false

  • 返回：{Number}

从该 Buffer 指定的带有特定尾数格式（readUInt32BE() 返回一个较大的尾数，readUInt32LE() 返回一个较小的尾数）的 offset 位置开始读取一个无符号的32位整数值。

设置 noAssert 为 true ，将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

例子：

  1. const buf = Buffer.from([0x3, 0x4, 0x23, 0x42]);
  3. buf.readUInt32BE(0);
  4. // Returns: 0x03042342
  5. console.log(buf.readUInt32LE(0));
  6. // Returns: 0x42230403

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

  • string {String} 需要被写入到 Buffer 的字节

  • offset {Number} 默认：0

  • length {Number} 默认：buffer.length - offset

  • encoding {String} 默认：'utf8'

  • 返回：{Number} 被写入的字节数

在 Buffer 的 offset 位置使用给定的 encoding 写入 string 。length 参数是写入的字节数。如果 Buffer 没有足够的空间以适应整个字符串，只会写入字符串的一部分，然而，它不会只写入已编码的字符部分。

  1. const buf = Buffer.allocUnsafe(256);
  2. const len = buf.write('\u00bd + \u00bc = \u00be', 0);
  3. console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`);
  4. // Prints: 12 bytes: ½ + ¼ = ¾

buf.writeIntBE(value, offset, byteLength[, noAssert])

buf.writeIntLE(value, offset, byteLength[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - byteLength

  • byteLength {Number} 默认：0 < byteLength <= 6

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

通过指定的 offset 和 byteLength 将 value 写入到当前 Buffer 中。支持多达 48 位的精度。例如：

  1. const buf1 = Buffer.allocUnsafe(6);
  2. buf1.writeUIntBE(0x1234567890ab, 0, 6);
  3. console.log(buf1);
  4. // Prints: <Buffer 12 34 56 78 90 ab>
  6. const buf2 = Buffer.allocUnsafe(6);
  7. buf2.writeUIntLE(0x1234567890ab, 0, 6);
  8. console.log(buf2);
  9. // Prints: <Buffer ab 90 78 56 34 12>

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

当值不是一个整数时，它的行为是不确定的。

buf.writeFloatBE(value, offset[, noAssert])

buf.writeFloatLE(value, offset[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - 4

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

从该 Buffer 指定的带有特定尾数格式（writeFloatBE() 写入一个较大的尾数，writeFloatLE() 写入一个较小的尾数）的 offset 位置开始写入 value 。当值不是一个32位浮点值时，它的行为是不确定的。

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

例子：

  1. const buf = Buffer.allocUnsafe(4);
  2. buf.writeFloatBE(0xcafebabe, 0);
  4. console.log(buf);
  5. // Prints: <Buffer 4f 4a fe bb>
  7. buf.writeFloatLE(0xcafebabe, 0);
  9. console.log(buf);
  10. // Prints: <Buffer bb fe 4a 4f>

buf.writeDoubleBE(value, offset[, noAssert])

buf.writeDoubleLE(value, offset[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - 8

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

从该 Buffer 指定的带有特定尾数格式（writeDoubleBE() 写入一个较大的尾数，writeDoubleLE() 写入一个较小的尾数）的 offset 位置开始写入 value 。value 参数应当是一个有效的64位双精度值。当值不是一个64位双精度值时，它的行为是不确定的。

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

例子：

  1. const buf = Buffer.allocUnsafe(8);
  2. buf.writeDoubleBE(0xdeadbeefcafebabe, 0);
  4. console.log(buf);
  5. // Prints: <Buffer 43 eb d5 b7 dd f9 5f d7>
  7. buf.writeDoubleLE(0xdeadbeefcafebabe, 0);
  9. console.log(buf);
  10. // Prints: <Buffer d7 5f f9 dd b7 d5 eb 43>

buf.writeInt8(value, offset[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - 1

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

通过指定的 offset 将 value 写入到当前 Buffer 中。这个 value 应当是一个有效的有符号的8位整数。当值不是一个有符号的8位整数时，它的行为是不确定的。

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

这个 value 作为一个2的补码的有符号的整数被解释执行和写入。

  1. const buf = Buffer.allocUnsafe(2);
  2. buf.writeInt8(2, 0);
  3. buf.writeInt8(-2, 1);
  4. console.log(buf);
  5. // Prints: <Buffer 02 fe>

buf.writeInt16BE(value, offset[, noAssert])

buf.writeInt16LE(value, offset[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - 2

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

从该 Buffer 指定的带有特定尾数格式（writeInt16BE() 写入一个较大的尾数，writeInt16LE() 写入一个较小的尾数）的 offset 位置开始写入 value 。value 参数应当是一个有效的有符号的16位整数。当值不是一个有符号的16位整数时，它的行为是不确定的。

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

这个 value 作为一个2的补码的有符号的整数被解释执行和写入。

  1. const buf = Buffer.allocUnsafe(4);
  2. buf.writeInt16BE(0x0102, 0);
  3. buf.writeInt16LE(0x0304, 2);
  4. console.log(buf);
  5. // Prints: <Buffer 01 02 04 03>

buf.writeInt32BE(value, offset[, noAssert])

buf.writeInt32LE(value, offset[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - 4

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

从该 Buffer 指定的带有特定尾数格式（writeInt32BE() 写入一个较大的尾数，writeInt32LE() 写入一个较小的尾数）的 offset 位置开始写入 value 。value 参数应当是一个有效的有符号的32位整数。当值不是一个有符号的32位整数时，它的行为是不确定的。

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

这个 value 作为一个2的补码的有符号的整数被解释执行和写入。

  1. const buf = Buffer.allocUnsafe(8);
  2. buf.writeInt32BE(0x01020304, 0);
  3. buf.writeInt32LE(0x05060708, 4);
  4. console.log(buf);
  5. // Prints: <Buffer 01 02 03 04 08 07 06 05>

buf.writeUIntBE(value, offset, byteLength[, noAssert])

buf.writeUIntLE(value, offset, byteLength[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - byteLength

  • byteLength {Number} 默认：0 < byteLength <= 6

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

通过指定的 offset 和 byteLength 将 value 写入到当前 Buffer 中。支持多达 48 位的精度。例如：

  1. const buf = Buffer.allocUnsafe(6);
  2. buf.writeUIntBE(0x1234567890ab, 0, 6);
  3. console.log(buf);
  4. // Prints: <Buffer 12 34 56 78 90 ab>

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

当值不是一个无符号的整数时，它的行为是不确定的。

buf.writeUInt8(value, offset[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - 1

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

通过指定的 offset 将 value 写入到当前 Buffer 中。这个 value 应当是一个有效的无符号的8位整数。当值不是一个无符号的8位整数时，它的行为是不确定的。

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

  1. const buf = Buffer.allocUnsafe(4);
  2. buf.writeUInt8(0x3, 0);
  3. buf.writeUInt8(0x4, 1);
  4. buf.writeUInt8(0x23, 2);
  5. buf.writeUInt8(0x42, 3);
  7. console.log(buf);
  8. // Prints: <Buffer 03 04 23 42>

buf.writeUInt16BE(value, offset[, noAssert])

buf.writeUInt16LE(value, offset[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - 2

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

从该 Buffer 指定的带有特定尾数格式（writeUInt16BE() 写入一个较大的尾数，writeUInt16LE() 写入一个较小的尾数）的 offset 位置开始写入 value 。value 参数应当是一个有效的无符号的16位整数。当值不是一个无符号的16位整数时，它的行为是不确定的。

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

  1. const buf = Buffer.allocUnsafe(4);
  2. buf.writeUInt16BE(0xdead, 0);
  3. buf.writeUInt16BE(0xbeef, 2);
  5. console.log(buf);
  6. // Prints: <Buffer de ad be ef>
  8. buf.writeUInt16LE(0xdead, 0);
  9. buf.writeUInt16LE(0xbeef, 2);
  11. console.log(buf);
  12. // Prints: <Buffer ad de ef be>

buf.writeUInt32BE(value, offset[, noAssert])

buf.writeUInt32LE(value, offset[, noAssert])

  • value {Number} 需要被写入到 Buffer 的字节

  • offset {Number} 0 <= offset <= buf.length - 4

  • noAssert {Boolean} 默认：false

  • 返回：{Number} 偏移加上被写入的字节数

从该 Buffer 指定的带有特定尾数格式（writeUInt32BE() 写入一个较大的尾数，writeUInt32LE() 写入一个较小的尾数）的 offset 位置开始写入 value 。value 参数应当是一个有效的无符号的32位整数。当值不是一个无符号的32位整数时，它的行为是不确定的。

将 noAssert 设为 true 将跳过对 value 和 offset 的验证。这意味着 value 可能对于这个特定的函数来说过大，并且 offset 可能超出该 Buffer 的末端，导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

  1. const buf = Buffer.allocUnsafe(4);
  2. buf.writeUInt32BE(0xfeedface, 0);
  4. console.log(buf);
  5. // Prints: <Buffer fe ed fa ce>
  7. buf.writeUInt32LE(0xfeedface, 0);
  9. console.log(buf);
  10. // Prints: <Buffer ce fa ed fe>