Introduction détaillée aux modules de mise en mémoire tampon et de streaming dans Node.js_node.js

Module tampon

js a été conçu à l'origine pour les navigateurs, il peut donc bien gérer les chaînes codées en Unicode, mais il ne peut pas bien gérer les données binaires. Il s'agit d'un problème avec Node.js car Node.js est conçu pour envoyer et recevoir des données sur le réseau, souvent au format binaire. Par exemple :

- Envoyer et recevoir des données via une connexion TCP
- Lire des données binaires à partir d'images ou de fichiers compressés
- Lire et écrire des données du système de fichiers
- Traiter les flux de données binaires du réseau

Le module Buffer apporte une méthode de stockage de données brutes à Node.js, afin que les données binaires puissent être utilisées dans le contexte de js. Chaque fois que vous avez besoin de gérer des données déplacées lors d'opérations d'E/S dans Node.js, il est possible d'utiliser le module Buffer.

Classe : Tampon

La classe Buffer est un type de variable globale utilisé pour traiter directement les données binaires. Il peut être construit de différentes manières.

Les données originales sont enregistrées dans une instance de la classe Buffer. Une instance Buffer est similaire à un tableau d'entiers

1.new Buffer(size) : alloue un nouveau tampon dont la taille est de 8 bits
. 2.new Buffer(array) : allouez un nouveau tampon à l'aide d'un tableau d'octets de 8 bits
. 3.new Buffer(str, [encoding]):encoding Type de chaîne - quelle méthode d'encodage utiliser, les paramètres sont facultatifs.

4. Méthode de classe : Buffer.isEncoding(encoding) : Si l'encodage donné est valide, renvoie true, sinon renvoie false.
5. Méthode de classe : Buffer.isBuffer(obj) : Testez si cet obj est un Buffer Return Boolean
. 6. Méthode de classe : Buffer.concat(list, [totalLength]) : liste type de tableau {Array}, tableau Buffer, utilisé pour être connecté. totalLength {Number} type La taille totale de tous les Buffers du tableau Buffer ci-dessus.
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 bin = nouveau tampon([ 0x48, 0x65, 0x6c, 0x6c, 0x6c ]);

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 :

bac[0]; // => 0x48;

Les tampons et les chaînes peuvent être convertis les uns aux autres. Par exemple, les données binaires peuvent être converties en chaînes en utilisant l'encodage spécifié :

Copier le code Le code est le suivant :

var str = bin.toString('utf-8'); // => "bonjour"

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

Copier le code Le code est le suivant :

1.[0x48, 0x65, 0x6c, 0x6c, 0x6c]
2. ^ ^ ^
3. |
4. bin bin.slice(2)

Tampon d'écriture

Copier le code Le code est le suivant :

var buffer = new Buffer(8);//Créer un tampon alloué à 8 octets de mémoire
console.log(buffer.write('a','utf8'));//Sortie 1

Cela écrira le caractère "a" dans le tampon et le nœud renvoie le nombre d'octets écrits dans le tampon après le codage. Le codage UTF-8 de la lettre a occupe ici 1 octet.

Tampon de copie

Node.js fournit une méthode pour copier l'intégralité du contenu d'un objet Buffer vers un autre objet Buffer. Nous ne pouvons copier qu'entre des objets Buffer existants, ils doivent donc être créés.

Copier le code Le code est le suivant :

buffer.copy(bufferToCopyTo)

Parmi eux, bufferToCopyTo est l'objet Buffer cible à copier. Exemple ci-dessous :

Copier le code Le code est le suivant :

var buffer1 = nouveau Buffer(8);
buffer1.write('enchanté de vous rencontrer','utf8');
var buffer2 = nouveau Buffer(8);
buffer1.copy(buffer2);
console.log(buffer2.toString());//enchanté de vous rencontrer

Module Flux

Dans les systèmes d'exploitation de type UNIX, les flux sont un concept standard. Il existe trois flux principaux comme suit :

1.Entrée standard
2. Sortie standard
3.Erreur standard

Flux lisible

Si les tampons sont la façon dont Node.js gère les données brutes, alors les flux sont généralement la façon dont Node.js déplace les données. Les flux dans Node.js sont lisibles ou inscriptibles. De nombreux modules de Node.js utilisent des flux, notamment HTTP et le système de fichiers.

Supposons que nous créions un fichier classesmates.txt et que nous lisions une liste de noms afin d'utiliser ces données. Puisque les données sont un flux, cela signifie que vous pouvez agir sur les données dès les premiers octets avant de terminer la lecture du fichier. Il s'agit d'un modèle courant dans Node.js :

.

Copier le code Le code est le suivant :

var fs = require('fs');
var stream = fs.ReadStream('classmates.txt');
stream.setEncoding('utf8');
stream.on('data', fonction (morceau) {
console.log('lire quelques données')
});
stream.on('close', function() {
console.log('toutes les données sont lues')
});

Dans l'exemple ci-dessus, les données d'événement sont déclenchées lorsque de nouvelles données sont reçues. L'événement close est déclenché lorsque la lecture du fichier est terminée.

Flux inscriptible

Évidemment, nous pouvons également créer des flux inscriptibles dans lesquels écrire des données. Cela signifie qu'avec un simple script, vous pouvez utiliser un flux pour lire dans un fichier puis écrire dans un autre fichier :

Copier le code Le code est le suivant :

var fs = require('fs');
var readableStream = fs.ReadStream('classmates.txt');
var writableStream = fs.writeStream('names.txt');
readableStream.setEncoding('utf8');
readableStream.on('data', function (morceau) {
writableStream.write(chunk);
});
readableStream.on('close', function() {
writeableStream.end();
});

Lorsqu'un événement de données est reçu, les données sont désormais écrites dans le flux inscriptible.

readable.setEncoding(encoding) : retour : this

readable.resume() : identique à ci-dessus. Cette méthode permet au flux lisible de continuer à déclencher des événements de données.

readable.pause() : Identique à ci-dessus. Cette méthode amène un flux en mode fluide à arrêter de déclencher des événements de données, à passer en mode non fluide et à laisser les données disponibles suivantes dans la mémoire tampon interne.
Classe : stream.Writable

L'interface de flux Writable est une abstraction des données que vous écrivez sur une cible.

1.writable.write(chunk, [encoding], [callback]):

chunk {String | Buffer} Données à écrire
encoding Encodage {String}, si chunk est une chaîne
callback {Function} rappel après l'écriture du bloc de données
Renvoie : {Boolean} true si les données ont été entièrement traitées.

Cette méthode écrit les données sur le système sous-jacent et appelle le rappel donné une fois les données traitées.

2.writable.cork() : force toutes les écritures à rester.

Les données conservées seront écrites lorsque .uncork() ou .end() sera appelé.

3.writable.end([chunk], [encoding], [callback])

chunk {String | Buffer} facultatif, données à écrire
encoding Encodage {String}, si chunk est une chaîne
callback {Fonction} facultatif, rappel après la fin du flux
Appeler write() après avoir appelé end() générera une erreur.

Copier le code Le code est le suivant :

// Écrivez « bonjour » et terminez par « monde ! »
http.createServer(fonction (req, res) {
res.write('bonjour, ');
res.end('monde!');
// Aucune autre écriture n'est autorisée maintenant
});