1. Analyse d'ouverture
Le soi-disant tampon tampon signifie "zone de stockage temporaire", qui est un morceau de mémoire qui stocke temporairement les données d'entrée et de sortie.
Le langage JS lui-même n'a que des types de données de chaîne et aucun type de données binaires. Par conséquent, NodeJS fournit un tampon de constructeur global qui est pair vers la chaîne pour fournir des opérations sur des données binaires. En plus de lire des fichiers pour obtenir des instances de tampon, il peut également être construit directement, par exemple:
La copie de code est la suivante:
var tampon = nouveau tampon ([0x68, 0x65, 0x6c, 0x6c, 0x6f]);
Le tampon est similaire à une chaîne. En plus d'utiliser l'attribut .Length pour obtenir la longueur d'octet, vous pouvez également utiliser la méthode [index] pour lire les octets en position spécifiée, par exemple:
La copie de code est la suivante:
tampon [0]; // 0x68;
Le tampon et la chaîne peuvent être convertis les uns aux autres, par exemple, les données binaires peuvent être converties en chaînes à l'aide d'un codage spécifié:
La copie de code est la suivante:
var str = buffer.toString ("utf-8"); // Bonjour
Convertit une chaîne en données binaires sous l'encodage spécifié:
La copie de code est la suivante:
var buffer = new tamper ("Hello", "utf-8"); // <tampon 68 65 6c 6c 6f>
Une petite différence:
Il existe une différence importante entre un tampon et une chaîne. La chaîne est en lecture seule, et toute modification de la chaîne se traduit par une nouvelle chaîne, et la chaîne d'origine reste inchangée.
Quant au tampon, il ressemble plus à un tableau de langue C qui peut effectuer des opérations de pointeur. Par exemple, les octets à une certaine position peuvent être directement modifiés dans la méthode [index].
-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
La méthode Slice ne renvoie pas un nouveau tampon, mais renvoie plutôt un pointeur vers un emplacement au milieu du tampon d'origine, comme illustré ci-dessous.
[0x68, 0x65, 0x6c, 0x6c, 0x6f]
^ ^
| |
bin bin.slice (2)
Par conséquent, la modification du tampon renvoyé par la méthode Slice agira sur le tampon d'origine, par exemple:
La copie de code est la suivante:
var tampon = nouveau tampon ([0x68, 0x65, 0x6c, 0x6c, 0x6f]);
var sub = bin.slice (2);
sub [0] = 0x65;
console.log (tampon); // <tampon 68 65 65 6c 6f>
Si vous souhaitez copier un tampon, vous devez d'abord créer un nouveau tampon et copier les données dans le tampon d'origine via la méthode .copy.
Ceci est similaire à la demande de nouveau morceau de mémoire et à la copie des données dans la mémoire existante. Voici un exemple.
La copie de code est la suivante:
var tampon = nouveau tampon ([0x68, 0x65, 0x6c, 0x6c, 0x6f]);
var dup = nouveau tampon (bin.length);
tampon.copy (dup);
dup [0] = 0x48;
console.log (tampon); // <tampon 68 65 6c 6c 6f>
Console.log (DUP); // <tampon 48 65 65 6c 6f>
En bref, Buffer étend les capacités de traitement des données de JS des chaînes aux données binaires arbitraires.
Ce qui précède vous permet de comprendre ce qu'est un tampon. Parlons de la façon de l'utiliser et des scénarios d'utilisation spécifiques ci-dessous.
Deuxièmement, parlez de tampon
JavaScript est très convivial pour le traitement des chaînes, et qu'il s'agisse d'un octet large ou d'une chaîne d'octet unique, il est considéré comme une chaîne. Le nœud doit traiter les protocoles réseau, les bases de données d'exploitation, le traitement des images, les téléchargements de fichiers, etc., et doit également traiter une grande quantité de données binaires. Les cordes qui les accompagnent sont loin de répondre à ces exigences, alors le tampon a vu le jour.
Structure de tampon
Le tampon est un module typique qui combine JavaScript et C ++. La pièce liée aux performances est implémentée en C ++ et la pièce non liée aux performances est implémentée en JavaScript.
Le nœud est installé en mémoire lorsque le processus démarre et le place dans l'objet global, il n'est donc pas nécessaire de l'exiger.
Objet tampon: similaire à un tableau, ses éléments sont à deux chiffres en hexadécimal.
Allocation de mémoire tampon
L'allocation de mémoire de l'objet tampon n'est pas dans la mémoire du tas de V8, mais il implémente l'application de mémoire au niveau C ++ du nœud.
Afin d'utiliser efficacement l'application de mémoire, Node utilise le mécanisme d'allocation de la dalle, qui est un mécanisme de gestion de la mémoire dynamique qui applique divers systèmes d'exploitation * NIX. Il y a trois états de dalle:
(1) Plein: État entièrement alloué
(2) Partial: statut d'allocation partiel
(3) vide: État non affecté
Conversion de tampon
Les objets tampons peuvent être convertis en chaînes, et les types de codage pris en charge sont les suivants:
ASCII, UTF-8, UTF-16LE / UCS-2, base64, binaire, hex
Chaîne à tampon
Nouveau tampon (str, [codage]), UTF-8 par défaut
buf.write (string, [offset], [longueur], [codage])
Tampon à la chaîne
buf.tostring ([codage], [start], [fin])
Types de codage qui ne sont pas pris en charge par du tampon
Déterminez s'il le prend en charge par tampon.isencoding (codage)
IconV-Lite: Pure JavaScript Implémentation, plus légère, meilleure performance sans conversion C ++ à JavaScript
iconv: appeler la bibliothèque libiconv en C ++ termine
Épissage de tampon
Remarque "res.on ('data', fonction (chunk) {})", où le morceau de paramètre est un objet tampon. L'utilisation directe de Stitching + sera automatiquement convertie en chaîne. Pour des caractères d'octets larges, un code brouillé peut se produire.
Solution:
(1) Grâce à la méthode SetEncoding () dans le flux lisible, cette méthode permet à l'événement de données de passer un objet tampon, mais une chaîne codée, et le module StringEncoder est utilisé en interne.
(2) Stockage de l'objet tampon dans un tableau, et enfin l'assembler dans un grand tampon, puis le coder en une sortie de chaîne.
Le tampon est largement utilisé dans les E / S de fichiers et les E / S de réseau, et ses performances sont d'une grande importance et sont beaucoup plus élevées que celles des chaînes ordinaires.
En plus de la perte de performance de la conversion de chaîne, lors de l'utilisation d'un tampon, un paramètre Highwatermark est crucial pour l'impact des performances lors de la lecture d'un fichier.
un. Les paramètres Highwatermark ont un certain impact sur l'allocation et l'utilisation de la mémoire tampon.
né Le paramètre Highwatermark est trop petit, ce qui peut conduire à trop d'appels système.
Quand dois-je utiliser du tampon, quand ne devrais-je pas l'utiliser ------- Pure JavaScript prend en charge le code Unicode mais ne prend pas en charge binaire. Lors de la résolution de flux TCP ou de flux de fichiers, il est nécessaire de traiter les flux. Lorsque nous enregistrons des chaînes non UTF-8, des formats binaires et autres, nous devons utiliser "tampon".
3. Présenter des exemples
La copie de code est la suivante:
var buf = new tampon ("Ceci est le test de concat de texte!"), str = "Ceci est le test de concat texte!" ;
Console.Time ("Buffer Concat Test!");
var list = [];
var len = 100000 * buf.length;
pour (var i = 0; i <100000; i ++) {
list.push (buf);
len + = buf.length;
}
var s1 = buffer.concat (list, len) .toString ();
Console.Timeend ("Buffer Concat Test!");
Console.Time ("String Concat Test!");
var list = [];
pour (var i = 100000; i> = 0; i--) {
list.push (str);
}
var s2 = list.join ("");
Console.Timeend ("String Concat Test!");
Voici les résultats en cours:
La vitesse de lecture est certainement plus rapide et le tampon nécessite également le fonctionnement de ToString (). Ainsi, lorsque nous enregistrons des chaînes, nous devons toujours utiliser la chaîne. Même si nous épissons des cordes en grandes cordes, la vitesse des cordes ne sera pas plus lente que les tampons.
Alors, quand devons-nous utiliser à nouveau des tampons? Lorsqu'il n'y a aucun moyen, lorsque nous enregistrons des chaînes non UTF-8, des formats binaires et autres, nous devons les utiliser.
Quatre, résumons
(1) JavaScript convient au traitement des données codées Unicode, mais n'est pas conviviale au traitement des données binaires.
(2), donc lors du traitement des flux TCP ou des systèmes de fichiers, il est nécessaire de traiter les flux d'octets.
(3), Node a plusieurs méthodes de traitement, de création et de consommation de flux d'octets.
(4) Les données brutes sont stockées dans une instance de tampon. Un tampon est similaire à un tableau entier, mais sa mémoire est allouée à l'extérieur de la pile V8. La taille d'un tampon ne peut pas être modifiée.
(5), les types de codage traités sont: ASCII, UTF8, UTF16LE, UCS2 (alias pour UTF16Le), Base64, Binary, Hex.
(6) Le tampon est un élément global et une instance de tampon est obtenue par Buffer () directement nouveau.