精华 Node.js的Buffer那些你可能不知道的用法
发布于 8 年前 作者 leizongmin 44973 次浏览 来自 分享

原文地址:http://morning.work/page/2015-11/nodejs_buffer.html 转载请注明出处

前言

在大多数介绍Buffer的文章中,主要是围绕数据拼接和内存分配这两方面的。比如我们使用fs模块来读取文件内容的时候,返回的就是一个Buffer:

fs.readFile('filename', function (err, buf) {
  // <Buffer 2f 2a 2a 0a 20 2a 20 53 75 ... >
});

在使用nethttp模块来接收网络数据时,data事件的参数也是一个Buffer,这时我们还需要使用Buffer.concat()来做数据拼接:

var bufs = [];
conn.on('data', function (buf) {
  bufs.push(buf);
});
conn.on('end', function () {
  // 接收数据结束后,拼接所有收到的Buffer对象
  var buf = Buffer.concat(bufs);
});

还可以利用Buffer.toString()来做转换base64或十六进制字符的转换,比如:

console.log(new Buffer('hello, world!').toString('base64'));
// 转换成base64字符串:aGVsbG8sIHdvcmxkIQ==

console.log(new Buffer('aGVsbG8sIHdvcmxkIQ==', 'base64').toString());
// 还原base64字符串:hello, world!

console.log(new Buffer('hello, world!').toString('hex'));
// 转换成十六进制字符串:68656c6c6f2c20776f726c6421

console.log(new Buffer('68656c6c6f2c20776f726c6421', 'hex').toString());
// 还原十六进制字符串:hello, world!

一般情况下,单个Node.js进程是有最大内存限制的,以下是来自官方文档中的说明:

What is the memory limit on a node process?

Currently, by default v8 has a memory limit of 512MB on 32-bit systems, and 1.4GB on 64-bit systems. The limit can be raised by setting --max_old_space_size to a maximum of ~1024 (~1 GB) (32-bit) and ~4096 (~4GB) (64-bit), but it is recommended that you split your single process into several workers if you are hitting memory limits.

由于Buffer对象占用的内存空间是不计算在Node.js进程内存空间限制上的,因此,我们也常常会使用Buffer来存储需要占用大量内存的数据:

// 分配一个2G-1字节的数据
// 单次分配内存超过此值会抛出异常 RangeError: Invalid typed array length
var buf = new Buffer(1024 * 1024 * 1024 - 1);

以上便是Buffer的几种常见用法。然而,阅读Buffer的API文档时,我们会发现更多的是readXXX()writeXXX()开头的API,具体如下:

  • buf.readUIntLE(offset, byteLength[, noAssert])
  • buf.readUIntBE(offset, byteLength[, noAssert])
  • buf.readIntLE(offset, byteLength[, noAssert])
  • buf.readIntBE(offset, byteLength[, noAssert])
  • buf.readUInt8(offset[, noAssert])
  • buf.readUInt16LE(offset[, noAssert])
  • buf.readUInt16BE(offset[, noAssert])
  • buf.readUInt32LE(offset[, noAssert])
  • buf.readUInt32BE(offset[, noAssert])
  • buf.readInt8(offset[, noAssert])
  • buf.readInt16LE(offset[, noAssert])
  • buf.readInt16BE(offset[, noAssert])
  • buf.readInt32LE(offset[, noAssert])
  • buf.readInt32BE(offset[, noAssert])
  • buf.readFloatLE(offset[, noAssert])
  • buf.readFloatBE(offset[, noAssert])
  • buf.readDoubleLE(offset[, noAssert])
  • buf.readDoubleBE(offset[, noAssert])
  • buf.write(string[, offset][, length][, encoding])
  • buf.writeUIntLE(value, offset, byteLength[, noAssert])
  • buf.writeUIntBE(value, offset, byteLength[, noAssert])
  • buf.writeIntLE(value, offset, byteLength[, noAssert])
  • buf.writeIntBE(value, offset, byteLength[, noAssert])
  • buf.writeUInt8(value, offset[, noAssert])
  • buf.writeUInt16LE(value, offset[, noAssert])
  • buf.writeUInt16BE(value, offset[, noAssert])
  • buf.writeUInt32LE(value, offset[, noAssert])
  • buf.writeUInt32BE(value, offset[, noAssert])
  • buf.writeInt8(value, offset[, noAssert])
  • buf.writeInt16LE(value, offset[, noAssert])
  • buf.writeInt16BE(value, offset[, noAssert])
  • buf.writeInt32LE(value, offset[, noAssert])
  • buf.writeInt32BE(value, offset[, noAssert])
  • buf.writeFloatLE(value, offset[, noAssert])
  • buf.writeFloatBE(value, offset[, noAssert])
  • buf.writeDoubleLE(value, offset[, noAssert])
  • buf.writeDoubleBE(value, offset[, noAssert])

这些API为在Node.js中操作数据提供了极大的便利。假设我们要将一个整形数值存储到文件中,比如当前时间戳为1447656645380,如果将其当作一个字符串存储时,需要占用11字节的空间,而将其转换为二进制存储时仅需6字节空间即可:

var buf = new Buffer(6);

buf.writeUIntBE(1447656645380, 0, 6);
// <Buffer 01 51 0f 0f 63 04>

buf.readUIntBE(0, 6);
// 1447656645380

在使用Node.js编写一些底层功能时,比如一个网络通信模块、某个数据库的客户端模块,或者需要从文件中操作大量结构化数据时,以上Buffer对象提供的API都是必不可少的。

接下来将演示一个使用Buffer对象操作结构化数据的例子。

操作结构化数据

假设有一个学生考试成绩数据库,每条记录结构如下:

学号 课程代码 分数
XXXXXX XXXX XX

其中学号是一个6位的数字,课程代码是一个4位数字,分数最高分为100分。

在使用文本来存储这些数据时,比如使用CSV格式存储可能是这样的:

100001,1001,99
100002,1001,67
100003,1001,88

其中每条记录占用15字节的空间,而使用二进制存储时其结构将会是这样:

学号 课程代码 分数
3字节 2字节 1字节

每一条记录仅需要6字节的空间即可,仅仅是使用文本存储的40%!下面是用来操作这些记录的程序:

// 读取一条记录
// buf    Buffer对象
// offset 本条记录在Buffer对象的开始位置
// data   {number, lesson, score}
function writeRecord (buf, offset, data) {
  buf.writeUIntBE(data.number, offset, 3);
  buf.writeUInt16BE(data.lesson, offset + 3);
  buf.writeInt8(data.score, offset + 5);
}

// 写入一条记录
// buf    Buffer对象
// offset 本条记录在Buffer对象的开始位置
function readRecord (buf, offset) {
  return {
    number: buf.readUIntBE(offset, 3),
    lesson: buf.readUInt16BE(offset + 3),
    score: buf.readInt8(offset + 5)
  };
}

// 写入记录列表
// list  记录列表,每一条包含 {number, lesson, score}
function writeList (list) {
  var buf = new Buffer(list.length * 6);
  var offset = 0;
  for (var i = 0; i < list.length; i++) {
    writeRecord(buf, offset, list[i]);
    offset += 6;
  }
  return buf;
}

// 读取记录列表
// buf  Buffer对象
function readList (buf) {
  var offset = 0;
  var list = [];
  while (offset < buf.length) {
    list.push(readRecord(buf, offset));
    offset += 6;
  }
  return list;
}

我们可以再编写一段程序来看看效果:

var list = [
  {number: 100001, lesson: 1001, score: 99},
  {number: 100002, lesson: 1001, score: 88},
  {number: 100003, lesson: 1001, score: 77},
  {number: 100004, lesson: 1001, score: 66},
  {number: 100005, lesson: 1001, score: 55},
];
console.log(list);

var buf = writeList(list);
console.log(buf);
// 输出 <Buffer 01 86 a1 03 e9 63 01 86 a2 03 e9 58 01 86 a3 03 e9 4d 01 86 a4 03 e9 42 01 86 a5 03 e9 37>

var ret = readList(buf);
console.log(ret);
/* 输出
[ { number: 100001, lesson: 1001, score: 99 },
  { number: 100002, lesson: 1001, score: 88 },
  { number: 100003, lesson: 1001, score: 77 },
  { number: 100004, lesson: 1001, score: 66 },
  { number: 100005, lesson: 1001, score: 55 } ]
*/

lei-proto模块介绍

上面的例子中,当每一条记录的结构有变化时,我们需要修改readRecord()writeRecord(),重新计算每一个字段在Buffer中的偏移量,当记录的字段比较复杂时很容易出错。为此我编写了lei-proto模块,它允许你通过简单定义每条记录的结构即可生成对应的readRecord()和`writeRecord()函数。

首先执行以下命令安装此模块:

$ npm install lei-proto --save

使用lei-proto模块后,前文的例子可以改为这样:

var parsePorto = require('lei-proto');

// 生成指定记录结构的数据编码/解码器
var record = parsePorto([
  ['number', 'uint', 3],
  ['lesson', 'uint', 2],
  ['score', 'uint', 1]
]);

function readList (buf) {
  var list = [];
  var offset = 0;
  while (offset < buf.length) {
    list.push(record.decode(buf.slice(offset, offset + 6)));
    offset += 6;
  }
  return list;
}

function writeList (list) {
  return Buffer.concat(list.map(record.encodeEx));
}

运行与上文同样的测试程序,可看到其结果是一样的:

<Buffer 01 86 a1 03 e9 63 01 86 a2 03 e9 58 01 86 a3 03 e9 4d 01 86 a4 03 e9 42 01 86 a5 03 e9 37>
[ { number: 100001, lesson: 1001, score: 99 },
  { number: 100002, lesson: 1001, score: 88 },
  { number: 100003, lesson: 1001, score: 77 },
  { number: 100004, lesson: 1001, score: 66 },
  { number: 100005, lesson: 1001, score: 55 } ]

关于lei-proto模块的详细使用方法可访问该模块的主页浏览:https://github.com/leizongmin/node-lei-proto

对此感兴趣的读者也可研究一下其实现原理。

扩展阅读

9 回复

感兴趣的可以看看 bearcat-buffer
老雷这个编码方式还可以进一步优化

老雷牛逼,非常好的一篇文章

@DoubleSpout 这篇文章还是有很多细节没说清楚,打算再写一篇深入的

LE和RE有什么区别?

来自炫酷的 CNodeMD 越来越喜欢material design😁

前四个函数是我添加的飘过 当时TJF还在 :-) @leizongmin

@XGHeaven 专业术语为「字节序」,指的是多字节的数据在内存中的存放顺序

  • LE - Little Endian
  • BE - Big Endian

详细解释可参考以下链接: http://songlee24.github.io/2015/05/02/endianess/ https://zh.wikipedia.org/wiki/字节序

@yorkie 1024个赞👍

@leizongmin 干货啊,谢谢老雷大大。 buffer.png 在阅读文章的时候。遇到上图时间戳字符串占用字节数的部分,为什么是11bytes呢? 按照UTF-8 representation的话不是应该是13bytes吗?

回到顶部