Articles en ligne sur l'utilisation de Buffer dans Node.js Il y en a beaucoup, mais je pense qu'ils ne sont pas encore assez détaillés, donc cet article présente principalement quelques utilisations de Buffer dans Node.js que vous ne connaissez peut-être pas. L'article le présente en détail. Les amis qui en ont besoin peuvent s'y référer. .Jetons un coup d'œil ensemble.
Préface
Dans la plupart des articles présentant Buffer, ils se concentrent principalement sur les deux aspects de l'épissage des données et. allocation de mémoire. Lors de l'utilisation du module fs pour lire le contenu du fichier , un Buffer est renvoyé :
fs.readFile('filename', function (err, buf) {
// <Buffer 2f 2a 2a 0a 20 2a 20 53 75 ... >
});Copier après la connexion
Lors de l'utilisation du module net ou http pour recevoir des données réseau, les données event< Le paramètre de 🎜> est également un Buffer À ce stade, nous devons également utiliser pour l'épissage des données : Buffer.concat()
var bufs = [];
conn.on('data', function (buf) {
bufs.push(buf);
});
conn.on('end', function () {
// 接收数据结束后，拼接所有收到的 Buffer 对象
var buf = Buffer.concat(bufs);
});Copier après la connexion
Vous pouvez également utiliser
pour convertir en base64. ou des caractères hexadécimaux. Par exemple : Buffer.toString()
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!
Copier après la connexion
Généralement, un seul processus Node.js a une limite de mémoire maximale. Voici une explication tirée de la documentation officielle :
Quelle est la mémoire. limite sur un processus de nœud ?
Actuellement, par défaut, la v8 a une limite de mémoire de 512 Mo sur les systèmes 32 bits et de 1,4 Go sur les systèmes 64 bits. La limite peut être augmentée en définissant --max_old_space_size sur un. maximum de ~1024 (~1 Go) (32 bits) et ~4096 (~4 Go) (64 bits), mais il est recommandé de diviser votre processus unique en plusieurs nœuds de calcul si vous atteignez les limites de mémoire.
En raison de L'espace mémoire occupé par l'objet Buffer n'est pas pris en compte dans la limite d'espace mémoire du processus Node.js. Par conséquent, nous utilisons souvent Buffer pour stocker des données qui nécessitent une grande quantité de mémoire :
<. 🎜>Ce qui précède est Buffer. Cependant, en lisant la documentation de l'API de Buffer, nous trouverons plus d'API commençant par
// 分配一个 2G-1 字节的数据
// 单次分配内存超过此值会抛出异常 RangeError: Invalid typed array length
var buf = new Buffer(1024 * 1024 * 1024 - 1);
Copier après la connexion
et
, comme suit : readXXX()writeXXX()
readUIntLE(. offset, byteLength[, noAssert])-
buf.writeIntBE(value, offset, byteLength[, noAssert])-
buf.writeUInt16LE(value, offset[, noAssert])
-
buf.writeInt16BE(value, offset[, noAssert])
actuel
est 1447656645380. Si nous le stockons sous forme de chaîne, il occupera 11 octets d'espace et le convertira en binaire. Seuls 6 octets d'espace sont nécessaires pour le stockage :
Lorsque vous utilisez Node.js pour écrire certaines fonctions de bas niveau, comme un module de communication réseau, un module client d'une base de données, ou que vous devez lisez-le à partir d'un fichier Lors de l'exploitation de grandes quantités de données structurées, les API fournies par les objets Buffer ci-dessus sont essentielles.
var buf = new Buffer(6);
buf.writeUIntBE(1447656645380, 0, 6);
// <Buffer 01 51 0f 0f 63 04>
buf.readUIntBE(0, 6);
// 1447656645380
Copier après la connexion
Ce qui suit montre un exemple d'utilisation de l'objet Buffer pour manipuler des données structurées.
操作结构化数据
假设有一个学生考试成绩数据库，每条记录结构如下：
其中学号是一个 6 位的数字，课程代码是一个 4 位数字，分数最高分为 100 分。
在使用文本来存储这些数据时，比如使用 CSV 格式存储可能是这样的：
100001,1001,99
100002,1001,67
100003,1001,88
Copier après la connexion
其中每条记录占用 15 字节的空间，而使用二进制存储时其结构将会是这样：
每一条记录仅需要 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;
}Copier après la connexion
我们可以再编写一段程序来看看效果：
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 } ]
*/Copier après la connexion
lei-proto 模块介绍
上面的例子中，当每一条记录的结构有变化时，我们需要修改readRecord()和writeRecord() ，重新计算每一个字段在 Buffer 中的偏移量，当记录的字段比较复杂时很容易出错。为此我编写了lei-proto模块，它允许你通过简单定义每条记录的结构即可生成对应的readRecord()和`writeRecord()函数。
首先执行以下命令安装此模块：
$ npm install lei-proto --save
Copier après la connexion
使用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));
}Copier après la connexion
运行与上文同样的测试程序，可看到其结果是一样的：
<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 } ]Copier après la connexion
总结
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
