Explication détaillée de l'utilisation de Buffer pour encoder et décoder des données binaires dans Node.js

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 créer un tampon avec une chaîne dans un encodage spécifié :

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

Les encodages de caractères et identifiants 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 peuvent être complétés en cas de besoin. retour 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

Créer ou recevoir un tampon Après l'objet, 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 (utilisez la taille de la capacité du tampon. à) créer un Lorsque le tampon a été initialisé, il faut noter que les données mises en 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, ce sera modulo 256, et alors 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%6=0)
3 Si vous utilisez A. 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 que vous avez créé ou reçu un tampon, vous devrez peut-être extraire une partie des données du tampon. Vous pouvez diviser le tampon existant en spécifiant la position de départ pour en créer un autre A plus petit. buffer :

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. Il s'agit simplement d'un certain morceau de données mis en mémoire tampon par le parent. (précisé 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

Vous pouvez utiliser la copie pour copier une partie du tampon vers un autre tampon comme ceci :

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"

Le code ci-dessus copie la 9ème à la 9ème partie du tampon source. 20 octets au début du tampon cible.

Décodage des données mises en mémoire tampon

Les données mises en mémoire tampon peuvent être converties en une chaîne UTF-8 comme ceci :

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。

更多Node.js中使用Buffer编码、解码二进制数据详解相关文章请关注PHP中文网！