• Node.js Video Tutorials

Node.js - 缓冲区

上一页
下一页

Node.js 中的缓冲区类对象用于表示固定长度的字节序列。它存储原始数据，类似于整数数组，但对应于 V8 堆之外的原始内存分配。Node.js 中的 Buffer 类是 JavaScript Uint8Array 类的子类。尽管 Buffer 类实例是一个全局对象，但建议通过 import 或 require 语句显式引用该类。

在早期版本的 Node.js 中，缓冲区对象是用 new 运算符声明的：

var buf = new Buffer(10);

也可以从给定的数组创建一个缓冲区对象：

var buf = new Buffer([10, 20, 30, 40, 50]);

或从给定的字符串：

var buf = new Buffer("Simply Easy Learning", "utf-8");

但是，现在已弃用 new 关键字的使用。您需要使用以下静态方法来创建 Buffer 对象：

// Creates a zero-filled Buffer of length 10.
const buf1 = Buffer.alloc(10);

// Creates an uninitialized buffer of length 10.
const buf2 = Buffer.allocUnsafe(10);

// Creates a Buffer containing array
const buf3 = Buffer.from([1, 2, 3]);

// creates a buffer from string
const buf4 = Buffer.from('hello world', 'utf8');

静态方法

alloc()

分配一个指定大小（以字节为单位）的新缓冲区。

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

参数

  • size - 新缓冲区的所需长度。

  • fill - 用来预填充新缓冲区的 value。默认为 0。

  • encoding - 如果 fill 是字符串，则为其编码。默认为 'utf8'。

示例

const buf = Buffer.alloc(5);

console.log(buf);
输出
<Buffer 00 00 00 00 00>

allocUnsafe()

创建一个指定大小（以字节为单位）的未初始化缓冲区。

Buffer.allocUnsafe(size)

示例

const buf = Buffer.allocUnsafe(10);

console.log(buf);

buf.fill('a');

console.log(buf);
输出
<Buffer 38 67 ff aa 32 56 00 00 08 00>
<Buffer 61 61 61 61 61 61 61 61 61 61>

from()

使用范围在 0 – 255 之间的字节数组分配新的缓冲区。

示例

// Creates a new Buffer containing the UTF-8 bytes of the string 'buffer'.
const buf1 = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72]);
console.log(buf1);

// Creates a new Buffer from integer array.
const buf2 = Buffer.from([10, 20, 30, 40, 50]);
console.log(buf2);
输出
<Buffer 62 75 66 66 65 72>
<Buffer 0a 14 1e 28 32>

from()

创建一个包含字符串的新缓冲区。

Buffer.from(string[, encoding])

参数

string <string> 要编码的字符串。

encoding <string> 字符串的编码。默认为 'utf8'。encoding 参数标识在将字符串转换为字节时要使用的字符编码。

示例

const buf1 = Buffer.from('Hello World');
console.log(buf1);
console.log(buf1.toString());
输出
<Buffer 48 65 6c 6c 6f 20 57 6f 72 6c 64>
Hello World

compare()

比较缓冲区对象与其他缓冲区对象。

compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])

参数

  • target - 用于比较的缓冲区。

  • targetStart - 在 target 中开始比较的偏移量。默认为 0。

  • targetEnd - 在 target 中结束比较的偏移量（不包含）。默认为 target.length。

  • sourceStart - 在源缓冲区中开始比较的偏移量。默认为 0。

  • sourceEnd - 在源缓冲区中结束比较的偏移量（不包含）。默认为 buf.length。

该函数返回一个数字，指示第一个缓冲区在排序顺序中是位于第二个缓冲区对象之前、之后还是与之相同。

如果第二个与第一个相同，则返回 0

如果第二个缓冲区在排序时应该位于第一个缓冲区之前，则返回 1。

如果第二个缓冲区在排序时应该位于第一个缓冲区之后，则返回 -1。

示例

var buffer1 = Buffer.from('BALL');
var buffer2 = Buffer.from('BAT');
var result = buffer1.compare(buffer2);

if(result < 0) {
   console.log(buffer1 +" comes before " + buffer2);
} else if(result === 0) {
   console.log(buffer1 +" is same as " + buffer2);
} else {
   console.log(buffer1 +" comes after " + buffer2);
}
输出
BALL comes before BAT

在上面的示例中，将两个 Buffer 对象更改为：

var buffer1 = Buffer.from('CURE');
var buffer2 = Buffer.from('CORE');
输出
CURE comes after CORE

copy()

将数据从此缓冲区的某个区域复制到目标缓冲区的某个区域，即使目标内存区域与源内存区域重叠。

copy(target[, targetStart[, sourceStart[, sourceEnd]]])

参数

  • target - 要复制到的缓冲区。

  • targetStart - 开始写入的 target 中的偏移量。默认为 0。

  • sourceStart - 开始复制的 buf 中的偏移量。默认为 0。

  • sourceEnd - 停止复制的 buf 中的偏移量（不包含）。默认为 buf.length。

示例

var buffer1 = Buffer.from('Hello World');
var buffer2 = Buffer.allocUnsafe(buffer1.length);
var result = buffer1.compare(buffer2);

buffer1.copy(buffer2);
console.log("buffer2 content: " + buffer2.toString());
输出
buffer2 content: Hello World

entries()

返回缓冲区对象内容的 [index, byte] 对的迭代器。

示例

var buf = Buffer.from('Hello World');
for (const pair of buf.entries()) {
  console.log(pair);
}
输出
[ 0, 72 ]
[ 1, 101 ]
[ 2, 108 ]
[ 3, 108 ]
[ 4, 111 ]
[ 5, 32 ]
[ 6, 87 ]
[ 7, 111 ]
[ 8, 114 ]
[ 9, 108 ]
[ 10, 100 ]

slice()

返回一个由给定索引裁剪的新缓冲区

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

参数

  • start - 数字，可选，默认为 0

  • end - 数字，可选，默认为 buffer.length

返回值

返回一个新的缓冲区，由 start（默认为 0）和 end（默认为 buffer.length）索引进行偏移和裁剪。负索引从缓冲区的末尾开始。

示例

var buffer1 = Buffer.from('TutorialsPoint');
//slicing a buffer
var buffer2 = buffer1.slice(0,9);
console.log("buffer2 content: " + buffer2.toString());
输出
buffer2 content: Tutorials

write()

根据指定的编码将字符串写入缓冲区的偏移量。

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

参数

  • string - 要写入 buf 的字符串。

  • offset - 开始写入字符串之前要跳过的字节数。默认为 0。

  • length - 要写入的最大字节数（写入的字节数不会超过 buf.length - offset）。默认为 buf.length - offset。

  • encoding - 字符串的字符编码。默认为 'utf8'。

该函数返回写入的字节数。

示例

const buf = Buffer.alloc(256);

const len = buf.write("Simple Easy Learning");

console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`);
输出
20 bytes: Simple Easy Learning

toJSON()

返回给定缓冲区对象的 JSON 表示形式。

示例

const buf = Buffer.from("Simple Easy Learning");

var json = buf.toJSON();
console.log(json);
输出
{
  type: 'Buffer',
  data: [
     83, 105, 109, 112, 108, 101,
     32,  69,  97, 115, 121,  32,
     76, 101,  97, 114, 110, 105,
    110, 103
  ]
}

concat()

返回一个新的 Buffer，它是所有 Buffer 实例连接的结果。

concat(list[, totalLength])

参数

  • list - 要连接的 Buffer 或 Uint8Array 实例列表。

  • totalLength - 列表中 Buffer 实例连接后的总长度。

示例

var buffer1 = Buffer.from('TutorialsPoint ');
var buffer2 = Buffer.from('Simply Easy Learning');
var buffer3 = Buffer.concat([buffer1,buffer2]);

console.log("buffer3 content: " + buffer3.toString());
输出
buffer3 content: TutorialsPoint Simply Easy Learning

方法参考

类方法

序号 方法和描述
1

Buffer.isEncoding(encoding)

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

Buffer.isBuffer(obj)

测试obj是否为Buffer。
3

Buffer.byteLength(string[, encoding])

给出字符串的实际字节长度。encoding默认为'utf8'。它与String.prototype.length不同，因为String.prototype.length返回字符串中字符的个数。
4

Buffer.concat(list[, totalLength])

返回一个缓冲区，它是将列表中所有缓冲区连接在一起的结果。
5

Buffer.compare(buf1, buf2)

与buf1.compare(buf2)相同。对于排序缓冲区数组很有用。
打印页面
上一页
下一页
广告