Buffer类

类相关的方法和属性

实例相关的方法和属性


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

new Buffer(size)

  • size {Number}

分配一个 size 字节大小的新 Buffersize 必须小于等于 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);
  3. buf1[0] = 0x61;
  4. console.log(buf1.toString());
  5. // 'auffer'
  6. console.log(buf2.toString());
  7. // 'buffer' (copy is not changed)

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

  • arrayBuffer - 一个 arrayBuffernew ArrayBuffer().buffer 属性

  • byteOffset {Number} 默认:0

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

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

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

  1. const arr = new Uint16Array(2);
  2. arr[0] = 5000;
  3. arr[1] = 4000;
  4. const buf = new Buffer(arr.buffer); // shares the memory with arr;
  5. console.log(buf);
  6. // Prints: <Buffer 88 13 a0 0f>
  7. // changing the TypdArray changes the Buffer also
  8. arr[1] = 6000;
  9. console.log(buf);
  10. // 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
  6. const buf2 = new Buffer('7468697320697320612074c3a97374', 'hex');
  7. console.log(buf2.toString());
  8. // 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';
  2. console.log(`${str}: ${str.length} characters, ` +
  3. `${Buffer.byteLength(str, 'utf8')} bytes`);
  4. // ½ + ¼ = ¾: 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);
  3. buf1[0] = 0x61;
  4. console.log(buf1.toString());
  5. // 'auffer'
  6. console.log(buf2.toString());
  7. // 'buffer' (copy is not changed)

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

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

  • arrayBuffer - 一个 TypedArraynew 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;
  4. const buf = Buffer.from(arr.buffer); // shares the memory with arr;
  5. console.log(buf);
  6. // Prints: <Buffer 88 13 a0 0f>
  7. // changing the TypedArray changes the Buffer also
  8. arr[1] = 6000;
  9. console.log(buf);
  10. // Prints: <Buffer 88 13 70 17>

选填的 byteOffsetlength 参数指定一个将由 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
  6. const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
  7. console.log(buf2.toString());
  8. // prints: this is a tést

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

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

  • size {Number}

  • fill {Value} 默认:undefined

  • encoding {String} 默认:utf8

分配一个 size 字节大小的新 Buffer。如果 fillundefined ,该 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>

如果同时指定了 fillencoding 参数,将通过调用 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)Buffersize 必须小于等于 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;
  5. console.log(totalLength);
  6. const bufA = Buffer.concat([buf1, buf2, buf3], totalLength);
  7. console.log(bufA);
  8. console.log(bufA.length);
  9. // 42
  10. // <Buffer 00 00 00 00 ... >
  11. // 42

Buffer.compare(buf1, buf2)

  • buf1 {Buffer}

  • buf2 {Buffer}

  • 返回:{Number}

比较 buf1buf2 通常用于 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);
  2. console.log(buf.length);
  3. // Prints: 1234
  4. buf.write('some string', 0, 'ascii');
  5. console.log(buf.length);
  6. // 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);
  3. for (var i = 0; i < str.length; i++) {
  4. buf[i] = str.charCodeAt(i);
  5. }
  6. console.log(buf.toString('ascii'));
  7. // 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);
  3. console.log(json);
  4. // Prints: '{"type":"Buffer","data":[116,101,115,116]}'
  5. const copy = JSON.parse(json, (key, value) => {
  6. return value && value.type === 'Buffer' ? Buffer.from(value.data) : value;
  7. });
  8. console.log(copy.toString());
  9. // Prints: 'test'

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

  • start {Number} 默认:0

  • end {Number} 默认:buffer.length

  • 返回:{Buffer}

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

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

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

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

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

  1. const buf = Buffer.from('buffer');
  2. buf.slice(-6, -1).toString();
  3. // Returns 'buffe', equivalent to buf.slice(0, 5)
  4. buf.slice(-6, -2).toString();
  5. // Returns 'buff', equivalent to buf.slice(0, 4)
  6. buf.slice(-5, -2).toString();
  7. // 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 不是一个 StringNumber ,则会被强制转换到 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 的值可以是 StringBufferNumber 。字符串会默认用 UTF8 解释执行。Buffer 将会使用整个 Buffer(比较部分 Buffer 请使用 buf.slice() 方法)。数字在 0 到 255 的范围内。

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

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

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

  • byteOffset {Number} 默认:0

  • encoding {String} 默认:'utf8'

  • 返回:{Boolean}

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

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

  1. const buf = Buffer.from('this is a buffer');
  2. buf.includes('this');
  3. // returns true
  4. buf.includes('is');
  5. // returns true
  6. buf.includes(Buffer.from('a buffer'));
  7. // returns true
  8. buf.includes(97); // ascii for 'a'
  9. // returns true
  10. buf.includes(Buffer.from('a buffer example'));
  11. // returns false
  12. buf.includes(Buffer.from('a buffer example').slice(0, 8));
  13. // returns true
  14. buf.includes('this', 4);
  15. // 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('!');
  3. for (var i = 0; i < 26; i++) {
  4. buf1[i] = i + 97; // 97 is ASCII a
  5. }
  6. buf1.copy(buf2, 8, 16, 20);
  7. console.log(buf2.toString('ascii', 0, 25));
  8. // Prints: !!!!!!!!qrst!!!!!!!!!!!!!

例子:创建一个单一的 Buffer ,然后将一块区域的数据拷贝到同一个 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.copy(buf, 0, 4, 10);
  6. console.log(buf.toString());
  7. // efghijghijklmnopqrstuvwxyz

buf.compare(otherBuffer)

  • otherBuffer {Buffer}

  • 返回:{Number}

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

  • 如果 otherBufferbuf 相同,则返回 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');
  4. console.log(buf1.compare(buf1));
  5. // Prints: 0
  6. console.log(buf1.compare(buf2));
  7. // Prints: -1
  8. console.log(buf1.compare(buf3));
  9. // Prints: 1
  10. console.log(buf2.compare(buf1));
  11. // Prints: 1
  12. console.log(buf2.compare(buf3));
  13. // Prints: 1
  14. [buf1, buf2, buf3].sort(Buffer.compare);
  15. // produces sort order [buf1, buf3, buf2]

buf.equals(otherBuffer)

  • otherBuffer {Buffer}

  • 返回:{Boolean}

返回一个 boolean 标识,无论 thisotherBuffer 是否具有完全相同的字节。

  1. const buf1 = Buffer.from('ABC');
  2. const buf2 = Buffer.from('414243', 'hex');
  3. const buf3 = Buffer.from('ABCD');
  4. console.log(buf1.equals(buf2));
  5. // Prints: true
  6. console.log(buf1.equals(buf3));
  7. // 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
  12. for (var value of buf) {
  13. console.log(value);
  14. }
  15. // prints:
  16. // 98
  17. // 117
  18. // 102
  19. // 102
  20. // 101
  21. // 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'
  6. buf.readIntBE(0, 6).toString(16);
  7. // Returns: -546f87a9cbee

设置 noAsserttrue ,将跳过对 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位浮点值。

设置 noAsserttrue ,将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

  1. const buf = Buffer.from([1, 2, 3, 4]);
  2. buf.readFloatBE();
  3. // Returns: 2.387939260590663e-38
  4. buf.readFloatLE();
  5. // Returns: 1.539989614439558e-36
  6. buf.readFloatLE(1);
  7. // throws RangeError: Index out of range
  8. buf.readFloatLE(1, true); // Warning: reads passed end of buffer!
  9. // 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位双精度值。

设置 noAsserttrue ,将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

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

buf.readInt8(offset[, noAssert])

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

  • noAssert {Boolean} 默认:false

  • 返回:{Number}

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

设置 noAsserttrue ,将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

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

  1. const buf = Buffer.from([1, -2, 3, 4]);
  2. buf.readInt8(0);
  3. // returns 1
  4. buf.readInt8(1);
  5. // 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位整数值。

设置 noAsserttrue ,将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

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

  1. const buf = Buffer.from([1, -2, 3, 4]);
  2. buf.readInt16BE();
  3. // returns 510
  4. buf.readInt16LE(1);
  5. // 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位整数值。

设置 noAsserttrue ,将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

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

  1. const buf = Buffer.from([1, -2, 3, 4]);
  2. buf.readInt32BE();
  3. // returns 33424132
  4. buf.readInt32LE();
  5. // returns 67370497
  6. buf.readInt32LE(1);
  7. // 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'
  6. buf.readUIntBE(0, 6).toString(16);
  7. // Returns: ab9078563412

设置 noAsserttrue ,将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

buf.readUInt8(offset[, noAssert])

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

  • noAssert {Boolean} 默认:false

  • 返回:{Number}

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

设置 noAsserttrue ,将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

  1. const buf = Buffer.from([1, -2, 3, 4]);
  2. buf.readUInt8(0);
  3. // returns 1
  4. buf.readUInt8(1);
  5. // 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位整数值。

设置 noAsserttrue ,将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

例子:

  1. const buf = Buffer.from([0x3, 0x4, 0x23, 0x42]);
  2. buf.readUInt16BE(0);
  3. // Returns: 0x0304
  4. buf.readUInt16LE(0);
  5. // Returns: 0x0403
  6. buf.readUInt16BE(1);
  7. // Returns: 0x0423
  8. buf.readUInt16LE(1);
  9. // Returns: 0x2304
  10. buf.readUInt16BE(2);
  11. // Returns: 0x2342
  12. buf.readUInt16LE(2);
  13. // 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位整数值。

设置 noAsserttrue ,将跳过对 offset 的验证。这将允许 offset 超出缓冲区的末尾。

例子:

  1. const buf = Buffer.from([0x3, 0x4, 0x23, 0x42]);
  2. buf.readUInt32BE(0);
  3. // Returns: 0x03042342
  4. console.log(buf.readUInt32LE(0));
  5. // 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 写入 stringlength 参数是写入的字节数。如果 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} 偏移加上被写入的字节数

通过指定的 offsetbyteLengthvalue 写入到当前 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>
  5. const buf2 = Buffer.allocUnsafe(6);
  6. buf2.writeUIntLE(0x1234567890ab, 0, 6);
  7. console.log(buf2);
  8. // Prints: <Buffer ab 90 78 56 34 12>

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

例子:

  1. const buf = Buffer.allocUnsafe(4);
  2. buf.writeFloatBE(0xcafebabe, 0);
  3. console.log(buf);
  4. // Prints: <Buffer 4f 4a fe bb>
  5. buf.writeFloatLE(0xcafebabe, 0);
  6. console.log(buf);
  7. // 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 位置开始写入 valuevalue 参数应当是一个有效的64位双精度值。当值不是一个64位双精度值时,它的行为是不确定的。

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

例子:

  1. const buf = Buffer.allocUnsafe(8);
  2. buf.writeDoubleBE(0xdeadbeefcafebabe, 0);
  3. console.log(buf);
  4. // Prints: <Buffer 43 eb d5 b7 dd f9 5f d7>
  5. buf.writeDoubleLE(0xdeadbeefcafebabe, 0);
  6. console.log(buf);
  7. // 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} 偏移加上被写入的字节数

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

noAssert 设为 true 将跳过对 valueoffset 的验证。这意味着 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 位置开始写入 valuevalue 参数应当是一个有效的有符号的16位整数。当值不是一个有符号的16位整数时,它的行为是不确定的。

noAssert 设为 true 将跳过对 valueoffset 的验证。这意味着 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 位置开始写入 valuevalue 参数应当是一个有效的有符号的32位整数。当值不是一个有符号的32位整数时,它的行为是不确定的。

noAssert 设为 true 将跳过对 valueoffset 的验证。这意味着 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} 偏移加上被写入的字节数

通过指定的 offsetbyteLengthvalue 写入到当前 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 将跳过对 valueoffset 的验证。这意味着 value 可能对于这个特定的函数来说过大,并且 offset 可能超出该 Buffer 的末端,导致该值被直接丢弃。除非确定你的内容的正确性否则不应该被使用。

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

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

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

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

  • noAssert {Boolean} 默认:false

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

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

noAssert 设为 true 将跳过对 valueoffset 的验证。这意味着 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);
  6. console.log(buf);
  7. // 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 位置开始写入 valuevalue 参数应当是一个有效的无符号的16位整数。当值不是一个无符号的16位整数时,它的行为是不确定的。

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

  1. const buf = Buffer.allocUnsafe(4);
  2. buf.writeUInt16BE(0xdead, 0);
  3. buf.writeUInt16BE(0xbeef, 2);
  4. console.log(buf);
  5. // Prints: <Buffer de ad be ef>
  6. buf.writeUInt16LE(0xdead, 0);
  7. buf.writeUInt16LE(0xbeef, 2);
  8. console.log(buf);
  9. // 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 位置开始写入 valuevalue 参数应当是一个有效的无符号的32位整数。当值不是一个无符号的32位整数时,它的行为是不确定的。

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

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