Explication détaillée du module Buffer dans NodeJS_node.js

1, analyse d'ouverture

Le soi-disant tampon Buffer signifie « zone de stockage temporaire », qui est une section de mémoire qui stocke temporairement les données d'entrée et de sortie.

Le langage JS lui-même n'a qu'un type de données chaîne et aucun type de données binaire, donc NodeJS fournit un constructeur global Buffer équivalent à String pour fournir des opérations sur les données binaires. En plus de lire le fichier pour obtenir une instance du Buffer, il peut également être construit directement, par exemple :

Copier le code Le code est le suivant :

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 en octets, vous pouvez également utiliser la méthode [index] pour lire les octets à la position spécifiée, par exemple :

Copier le code Le code est le suivant :

tampon[0] ; // 0x68;

Le tampon et la chaîne peuvent être convertis l'un en l'autre. Par exemple, les données binaires peuvent être converties en chaîne en utilisant l'encodage spécifié :

Copier le code Le code est le suivant :

var str = buffer.toString("utf-8"); // bonjour

Convertir la chaîne en données binaires dans l'encodage spécifié :

Copier le code Le code est le suivant :

var buffer= new Buffer("bonjour", "utf-8") ; //

Une petite différence :

Il existe une différence importante entre Buffer et string. La chaîne est en lecture seule et toute modification de la chaîne entraîne la création d'une nouvelle chaîne, tandis que la chaîne d'origine reste inchangée.

Quant à Buffer, il ressemble plus à un tableau en langage C qui peut effectuer des opérations de pointeur. Par exemple, vous pouvez utiliser la méthode [index] pour modifier directement les octets à une certaine position.

-------------------------------------------------------------- --- ----------------------------------------------- --- ----------------------------------------------- --- ----------------------------------------------- --- --------------------------------

La méthode

slice ne renvoie pas un nouveau Buffer, mais renvoie plutôt un pointeur vers une position au milieu du Buffer d'origine, comme indiqué ci-dessous.

[ 0x68, 0x65, 0x6c, 0x6c, 0x6f ]
                                                              |
bin bin.slice(2)
Par conséquent, les modifications apportées au Buffer renvoyé par la méthode slice affecteront le Buffer d'origine, par exemple :

Copier le code Le code est le suivant :

var buffer= nouveau Buffer([ 0x68, 0x65, 0x6c, 0x6c, 0x6f ]) ;
var sub = bin.slice(2) ;
sous[0] = 0x65;
console.log(tampon); //

Si vous souhaitez copier un Buffer, vous devez d'abord créer un nouveau Buffer et copier les données dans le Buffer d'origine via la méthode .copy.

Cela revient à demander une nouvelle mémoire et à copier les données dans la mémoire existante. Ci-dessous un exemple.

Copier le code Le code est le suivant :

var buffer= nouveau Buffer([ 0x68, 0x65, 0x6c, 0x6c, 0x6f ]) ;
var dup = nouveau Buffer(bin.length) ;
buffer.copy(dup) ;
dup[0] = 0x48 ;
console.log(tampon); //
console.log(dup) ; //

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 est une brève introduction à ce qu'est Buffer. Parlons de comment l'utiliser et des scénarios d'utilisation spécifiques.

Deuxièmement, parlons de Buffer

JavaScript est très convivial pour le traitement des chaînes. Qu'il s'agisse d'une chaîne à octets larges ou d'une chaîne à un octet, elle est considérée comme une chaîne. Node doit traiter les protocoles réseau, faire fonctionner des bases de données, traiter des images, télécharger des fichiers, etc. Il doit également traiter une grande quantité de données binaires. Les chaînes intégrées sont loin de répondre à ces exigences, c'est pourquoi Buffer a vu le jour.

Structure du tampon

Buffer est un module typique qui combine Javascript et C. Les parties liées aux performances sont implémentées en C et les parties non liées aux performances sont implémentées en JavaScript.

Node a déjà chargé le Buffer dans la mémoire lorsque le processus démarre et le place dans l'objet global, il n'est donc pas nécessaire d'exiger

Objet Buffer : similaire à un tableau, ses éléments sont des chiffres hexadécimaux à deux chiffres.

Allocation de mémoire tampon

L'allocation mémoire de l'objet Buffer n'est pas dans la mémoire tas de la V8. L'application mémoire est implémentée au niveau C de Node.

Afin d'utiliser efficacement la mémoire demandée, Node adopte le mécanisme d'allocation slab est un mécanisme de gestion dynamique de la mémoire qui applique divers systèmes d'exploitation *nix. La dalle a trois états :

(1) complet : statut entièrement alloué

(2) partiel : statut d'attribution partielle

(3) vide : aucun statut attribué

Conversion de tampon

Les objets tampon peuvent être convertis vers et depuis des chaînes. Les types d'encodage pris en charge sont les suivants :

ASCII, UTF-8, UTF-16LE/UCS-2, Base64, binaire, hexadécimal

Chaîne vers tampon

nouveau Buffer(str, [encoding]), UTF-8 par défaut
buf.write(string, [offset], [length], [encoding])

Tampon vers chaîne

buf.toString([encodage], [début], [fin])

Type d'encodage non pris en charge par Buffer

Déterminez s'il est pris en charge par Buffer.isEncoding(encoding)

iconv-lite : implémentation JavaScript pure, plus légère, meilleures performances sans conversion C vers javascript

iconv : Appelez la bibliothèque libiconv de C pour terminer

Épissure de tampon

Faites attention à "res.on('data', function(chunk) {})". Le paramètre chunk est un objet Buffer le convertira automatiquement en chaîne pour les caractères à octets larges, les caractères tronqués. peut être généré,

Solution :

(1) Grâce à la méthode setEncoding() dans le flux lisible, cette méthode permet à l'événement de données d'être transmis non plus comme un objet Buffer, mais comme une chaîne codée, qui utilise le module StringEncoder en interne.

(2) Stockez temporairement l'objet Buffer dans un tableau, puis assemblez-le dans un grand Buffer, puis encodez-le dans une chaîne pour la sortie.

Le tampon est largement utilisé dans les E/S de fichiers et les E/S réseau. Ses performances sont très importantes et ses performances sont bien supérieures à celles des chaînes ordinaires.

En plus de la perte de performances lors de la conversion des chaînes, l'utilisation de Buffer a un paramètre highWaterMark qui est crucial pour les performances lors de la lecture de fichiers.

a. Le paramètre highWaterMark a un certain impact sur l'allocation et l'utilisation de la mémoire tampon.

b. Un réglage trop petit de highWaterMark peut entraîner un trop grand nombre d'appels système.

Quand utiliser le tampon et quand ne pas l'utiliser ------ Le javascript pur prend en charge le code Unicode mais pas le binaire Lorsqu'il s'agit d'un flux TCP ou d'un flux de fichier, il est nécessaire de traiter le flux lorsque nous enregistrons du non-. Chaînes utf-8, binaires et autres formats, il faut utiliser "Buffer".

3. Introduction des exemples

Copier le code Le code est le suivant :

var buf = new Buffer("c'est un test de concatération de texte !") ,str = "c'est un test de concatération de texte ;
console.time("buffer concat test !");
var liste = [] ;
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 liste = [] ;
pour (var i = 100000; i >= 0; i--) {
Liste.push(str) ;
>
var s2 = list.join("") ;
console.timeEnd("string concat test !") ;

Voici les résultats :

La vitesse de lecture de la chaîne est nettement plus rapide et le tampon nécessite également l'opération toString(). Ainsi, lorsque nous enregistrons une chaîne, nous devons toujours utiliser une chaîne. Même si une grande chaîne est fusionnée en une chaîne, elle ne sera pas plus lente que le tampon.

Alors, quand devons-nous à nouveau utiliser le tampon ? Lorsqu'il n'y a pas d'autre moyen, lorsque nous enregistrons des chaînes non utf-8, des formats binaires et autres, nous devons l'utiliser.

Quatre, résumé

(1), JavaScript convient au traitement des données codées Unicode, mais il n'est pas convivial pour le traitement des données binaires.
(2), donc lors du traitement de flux TCP ou de systèmes de fichiers, il est nécessaire de traiter des flux d'octets.
(3), Node dispose de plusieurs méthodes pour traiter, créer et consommer des flux d'octets.
(4) Les données originales sont stockées dans une instance de Buffer. Un Buffer est similaire à un tableau d'entiers, mais sa mémoire est allouée en dehors de la pile V8. La taille d'un Buffer ne peut pas être modifiée.
(5), les types d'encodage traités sont : ascii, utf8, utf16le, ucs2 (alias de utf16le), base64, binaire, hex.
(6), Buffer est un élément global et vous pouvez obtenir une instance de Buffer directement en utilisant new Buffer().