Comment utiliser Buffer pour encoder et décoder des données binaires dans Node.js

Cet article présente principalement l'explication détaillée de l'utilisation de Buffer pour encoder et décoder des données binaires dans Node.js. Buffer prend en charge ascii, utf8, ucs2, base64 et d'autres formats d'encodage

JavaScript est très efficace pour gérer les chaînes, mais comme il a été conçu à l'origine pour gérer des documents HTML, il n'est pas très efficace pour gérer les données binaires. JavaScript n'a pas de type d'octet, pas de types structurés, pas même de tableaux d'octets, seulement des nombres et des chaînes. (Texte original : JavaScript n'a pas de type d'octet - il a juste des nombres - ni de types structurés, ni http://skylitecellars.com/ même des tableaux d'octets : il a juste des chaînes.)

Parce que Node est basé sur JavaScript , il peut naturellement gérer des protocoles texte comme HTTP, mais vous pouvez également l'utiliser pour interagir avec des bases de données, gérer les téléchargements d'images ou de fichiers, etc. Vous pouvez imaginer à quel point il serait difficile de faire ces choses en utilisant simplement des chaînes. Auparavant, Node traitait les données binaires en codant des octets en caractères de texte, mais cette approche s'est avérée par la suite irréalisable, gaspillant des ressources, lente, peu flexible et difficile à maintenir.

Node a une implémentation de tampon binaire Buffer. Cette pseudo-classe fournit une série d'API pour traiter les données binaires, simplifiant les tâches qui nécessitent le traitement de données binaires. La longueur du tampon est déterminée par la longueur des données d'octets, et vous pouvez définir et obtenir de manière aléatoire les données d'octets dans le tampon.

Remarque : Il y a une particularité à propos de la classe Buffer. La mémoire occupée par les données d'octets dans le tampon n'est pas allouée sur le tas de mémoire JavaScrp

It VM, ce qui signifie que ces objets ne sera pas traité par l'algorithme de récupération de place de JavaScript, il est remplacé par une adresse mémoire permanente qui ne sera pas modifiée, ce qui évite également le gaspillage de CPU causé par la copie mémoire du contenu du tampon.

Créer un tampon

Vous pouvez créer un tampon avec une chaîne UTF-8, comme ceci :

var buf = new Buffer(‘Hello World!');

Vous pouvez également utiliser un encodage spécifié Tampon de création de chaîne :

var buf = new Buffer('8b76fde713ce', 'base64');

Les encodages et identifiants de caractères acceptables sont les suivants :

1.ascii - ASCI, applicable uniquement au jeu de caractères ASCII.

2.utf8 - UTF-8, cet encodage à largeur variable convient à n'importe quel caractère du jeu de caractères Unicode. Il est devenu l'encodage préféré dans le monde du Web et est également le type d'encodage par défaut de Node.
3.base64——Base64, cet encodage est basé sur 64 caractères ASCII imprimables pour représenter des données binaires. Base64 est généralement utilisé pour intégrer des données binaires dans des documents de caractères qui peuvent être convertis en chaînes et être complétés en cas de besoin. au format binaire d'origine.

S'il n'y a pas de données pour initialiser le tampon, vous pouvez créer un tampon vide avec la capacité spécifiée :

var buf = new Buffer(1024); // 创建一个1024字节的缓冲

Obtenir et définir les données du tampon

Après avoir créé ou reçu un objet tampon, vous souhaiterez peut-être afficher ou modifier son contenu. Vous pouvez accéder à un certain octet du tampon via l'opérateur [] :

var buf = new Buffer('my buffer content');
// 访问缓冲内第10个字节
console.log(buf[10]); // -> 99

Remarque : lorsque vous (. utiliser la capacité du tampon) Lors de la création d'un tampon initialisé, assurez-vous de noter que les données mises en mémoire tampon ne sont pas initialisées à 0, mais à des données aléatoires.

var buf = new Buffer(1024);
console.log(buf[100]); // -> 5 (某个随机值)

Vous pouvez modifier les données à n'importe quel endroit du tampon comme ceci :

buf[99] = 125; // 把第100个字节的值设置为125

Remarque : Dans certains cas, certaines opérations du tampon ne provoqueront pas d'erreurs, telles que :

1. La valeur maximale des octets dans le tampon est de 255. Si un octet se voit attribuer un nombre supérieur à 256, il sera modulo 256 et le résultat sera attribué à cet octet.

2. Si un certain octet dans le tampon reçoit une valeur de 256, sa valeur réelle sera 0 (Note du traducteur : en fait répété avec le premier, 256%256=0)
3. Le nombre à virgule flottante attribue une valeur à un certain octet dans le tampon, tel que 100,7. La valeur réelle sera la partie entière du nombre à virgule flottante - 100
4. la capacité du tampon, l’opération d’affectation échouera. Le tampon n’est en aucun cas modifié.

Vous pouvez utiliser l'attribut length pour obtenir la longueur du tampon :

var buf = new Buffer(100);
console.log(buf.length); // -> 100

Vous pouvez également utiliser la longueur du tampon pour parcourir le contenu du tampon afin de lire ou définir chaque octet :

var buf = new Buffer(100);
for(var i = 0; i < buf.length; i++) {
    buf[i] = i;
}

Le code ci-dessus crée un nouveau tampon contenant 100 octets et définit chaque octet dans le tampon de 0 à 99.

Diviser les données du tampon

Une fois qu'un tampon est créé ou reçu, vous devrez peut-être extraire une partie des données du tampon. Vous pouvez diviser les données du tampon existantes en spécifiant. la position de départ. buffer, créant ainsi un autre tampon plus petit :

var buffer = new Buffer("this is the content of my buffer");
var smallerBuffer = buffer.slice(8, 19);
console.log(smallerBuffer.toString()); // -> "the content"

Notez que lors du fractionnement d'un tampon, aucune nouvelle mémoire n'est allouée ou copiée. Le nouveau tampon utilise la mémoire du tampon parent, qui est juste un. référence à une certaine donnée dans le tampon parent (spécifiée par la position de départ). Ce passage contient plusieurs significations.

Tout d'abord, si votre programme modifie le contenu du tampon parent, ces modifications affecteront également les tampons enfants associés, car le tampon parent et le tampon enfant sont des objets JavaScript différents, il est donc facile de les ignorer. ce problème et provoque des bugs potentiels.

Deuxièmement, lorsque vous créez de cette manière un tampon enfant plus petit à partir du tampon parent, l'objet tampon parent sera toujours conservé une fois l'opération terminée et ne sera pas récupéré si vous n'y prêtez pas attention. , Il est facile de provoquer des fuites de mémoire.

Remarque : si vous vous inquiétez des fuites de mémoire, vous pouvez utiliser la méthode de copie au lieu de l'opération de copie par tranche qui sera présentée ci-dessous.

Copier les données du tampon

你可以像这样用copy将缓冲的一部分复制到另外一个缓冲：

var buffer1 = new Buffer("this is the content of my buffer");
var buffer2 = new Buffer(11);
var targetStart = 0;
var sourceStart = 8;
var sourceEnd = 19;
buffer1.copy(buffer2, targetStart, sourceStart, sourceEnd);
console.log(buffer2.toString()); // -> "the content"

上面代码，复制源缓冲的第9到20个字节到目标缓冲的开始位置。

解码缓冲数据

缓冲数据可以这样转换成一个UTF-8字符串：

var str = buf.toString();

还可以通过指定编码类型来将缓冲数据解码成任何编码类型的数据。比如，你想把一个缓冲解码成base64字符串，可以这么做：

var b64Str = buf.toString("base64");

使用toString函数，你还可以把一个UTF-8字符串转码成base64字符串：

var utf8String = 'my string';
var buf = new Buffer(utf8String);
var base64String = buf.toString('base64')

小结

有时候，你不得不跟二进制数据打交道，但是原生JavaScript又没有明确的方式来做这件事，于是Node提供了Buffer类，封装了一些针对连续内存块的操作。你可以在两个缓冲之间切分或复制内存数据。

你也可以把一个缓冲转换成某种编码的字符串，或者反过来，把一个字符串转化成缓冲，来访问或处理每个bit。

以上就是本文的全部内容，希望对大家的学习有所帮助，更多相关内容请关注PHP中文网！

相关推荐：

nodejs中实现路由功能的方法

NodeJs基本语法和类型的介绍

深入解析node.js的exports、module.exports与ES6的export、export default

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!