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

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 buffer

Vous pouvez créer un buffer à partir d'une chaîne UTF-8, comme ceci :

Le code est le suivant :

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

Vous pouvez également créer un tampon avec une chaîne d'encodage spécifié :

Le code est le suivant :

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

Les codages 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 ê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 :

Le code est le suivant :

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 []. :

Le code est le suivant :

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

Remarque : Lorsque vous créez un tampon initialisé (en utilisant la taille de la capacité du tampon), assurez-vous de noter que les données mises en tampon sont non initialisé à 0. Mais des données aléatoires.

Le code est le suivant :

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

Vous pouvez modifier les données à n'importe quelle position dans le tampon comme ceci :

Le code est le suivant :

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

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

1 La valeur maximale d'octets dans le tampon est de 255. Si un. l'octet reçoit une valeur supérieure à 256. Le nombre 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%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 buffer :

Le code est le suivant :

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

Vous pouvez également utiliser le buffer length pour parcourir le contenu du tampon à lire Ou définir chaque octet :

Le code est le suivant :

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 le contenu du tampon de 0 à 99 par octet.

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 du tampon, créant ainsi un autre tampon plus petit :

Le code est le suivant :

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 simplement une référence à une certaine donnée (spécifiée par la position de départ) du tampon parent. 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.

注意：如果你担心因此产生内存泄露问题，你可以使用copy方法来替代slice操作，下面将会介绍copy。

复制缓冲数据

你可以像这样用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。

以上就是Node.js中使用Buffer编码、解码二进制数据详解_node.js?1.1.2的内容，更多相关内容请关注PHP中文网（m.sbmmt.com）！