Module de tampon
JS a été initialement conçu pour les navigateurs, il peut donc bien gérer les chaînes codées par Unicode, mais elle 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 qui sont souvent transmises au format binaire sur le réseau. Par exemple:
- Envoyer et recevoir des données via la connexion TCP;
- lire les 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 de tampon apporte une méthode à Node.js pour stocker les données brutes, de sorte que les données binaires peuvent être utilisées dans le contexte de JS. Chaque fois que les données déplacées dans les opérations d'E / S doivent être traitées dans Node.js, il est possible d'utiliser le module tampon.
Classe: tampon
La classe de tampon est un type de variable global utilisé pour traiter directement les données binaires. Il peut être construit de différentes manières.
Les données brutes sont enregistrées dans une instance de la classe tampon. Une instance de tampon est similaire à un tableau d'entiers
1.Neuf tampon (taille): allouer un nouveau tampon de taille 8 bits octets dont la taille est la taille.
2.Neuf tampon (tableau): Attribuez un nouveau tampon pour utiliser un tableau d'octets 8 bits.
3.New Buffer (Str, [Encoding]): codage de chaîne Type-What Encoding Method est utilisé et les paramètres sont facultatifs.
4. Méthode de classe: Buffer.isEncoding (Encoding): Retour True Si le codage d'encodage donné est valide, sinon renvoyez false.
5. Méthode de classe: Buffer.isbuffer (OBJ): Testez si cet OBJ est un tampon. Retour booléen
6. Méthode de classe: buffer.concat (list, [totalngle]): list {array} Type de tableau, tableau de tampon, utilisé pour être connecté. TAUTALLONGHT {numéro} Type Taille totale de tous les tampons du tableau de tampon ci-dessus.
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 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 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:
bin [0]; // => 0x48;
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 = bin.toString ('utf-8'); // => "Bonjour"
Au lieu de retourner un nouveau tampon, la méthode .slice renvoie un pointeur vers un emplacement au milieu du tampon d'origine, comme indiqué ci-dessous.
La copie de code est la suivante:
1. [0x48, 0x65, 0x6c, 0x6c, 0x6c]
2. ^ ^
3. | |
4. Bin bin.slice (2)
Écrivez dans le tampon
La copie de code est la suivante:
var tampon = nouveau tampon (8); // créer un tampon avec 8 octets de mémoire alloués
console.log (buffer.write ('a', 'utf8')); // sortie 1
Cela écrira le personnage "A" dans le tampon, et le nœud renvoie le nombre d'octets écrits dans le tampon après avoir été encodé. Le codage UTF-8 de la lettre A ici prend 1 octet.
Tampon de copie
Node.js fournit une méthode pour copier l'intégralité du contenu de l'objet tampon dans un autre objet tampon. Nous ne pouvons copier que entre les objets tampons existants, nous devons donc les créer.
La copie de code est la suivante:
tampon.copy (buffertocopyto)
Parmi eux, BuffertoPopyto est l'objet tampon cible à copier. L'exemple suivant:
La copie de code est la suivante:
var tampon1 = nouveau tampon (8);
Buffer1.Write («Ravi de vous rencontrer», «UTF8»);
var tampon2 = nouveau tampon (8);
Buffer1.Copy (Buffer2);
console.log (buffer2.toString ()); // Ravi de vous rencontrer
Module de flux
Dans les systèmes d'exploitation de type UNIX, le streaming est un concept standard. Il y a trois courants principaux comme suit:
1. Entrée standard
2. Sortie standard
3. Erreurs standard
Flux lisible
Si le tampon est la façon dont Node.js gère les données brutes, le flux est généralement la façon dont Node.js déplace les données. Les flux dans Node.js sont lisibles ou écrivains. De nombreux modules dans Node.js utilisent des flux, y compris HTTP et les systèmes de fichiers.
Supposons que nous créons un fichier Classmates.txt et lisons la liste des noms à partir de celui-ci afin que nous puissions utiliser ces données. Étant donné que les données sont un flux, cela signifie qu'avant de terminer la lecture du fichier, vous pouvez agir sur les données des premiers octets reçus. Ceci est un modèle commun dans Node.js:
La copie de code est la suivante:
var fs = require ('fs');
var stream = fs.readstream ('classmates.txt');
Stream.SetEncoding ('UTF8');
stream.on ('data', fonction (chunk) {
Console.log («Lire certaines données»)
});
stream.on ('close', function () {
console.log («toutes les données sont lues»)
});
Dans l'exemple ci-dessus, les données de l'événement sont déclenchées lorsque de nouvelles données sont reçues. L'événement de clôture est déclenché lorsque la lecture du fichier est terminée.
Ruisseau en écriture
De toute évidence, nous pouvons également créer un flux écrit pour écrire des données. Cela signifie qu'un simple script peut être utilisé pour lire dans le fichier, puis écrire dans un autre fichier:
La copie de code est la suivante:
var fs = require ('fs');
var likeStream = fs.readStream ('classmates.txt');
var writeableStream = fs.writeStream ('names.txt');
LEALABLESTREAM.SETENCODING ('UTF8');
likeableStream.on ('data', fonction (chunk) {
writeableStream.Write (Chunk);
});
likeableStream.on ('close', function () {
writeableStream.end ();
});
Maintenant, lorsqu'un événement de données est reçu, les données sont écrites sur le flux écrivative.
lisible.setEncoding (Encoding): Retour: this
lisible.Resume (): Identique à ci-dessus. Cette méthode permet au flux lisible de continuer à déclencher l'événement de données.
lisible.pause (): Identique à ci-dessus. Cette méthode entraîne un flux en mode flux pour arrêter le déclenchement de l'événement de données, passer en mode non-flux et laisser les données disponibles suivantes dans le tampon interne.
Classe: Stream.Witable
L'interface de flux écrit est une abstraction des données que vous écrivez à une cible.
1.Witable.Write (Chunk, [Encoding], [rappel]):
Chunk {String | Buffer} Données à écrire
Encodage {String} Encoding, si Chunk est une chaîne
rappel {fonction} rappel après l'écriture de blocs de données
Return: {boolean} true si les données ont été traitées tous.
Cette méthode écrit des données sur le système sous-jacente et appelle le rappel donné après le traitement des données.
2.Witable.cork (): obligé de piéger toutes les écritures.
Les données bloquées seront écrites lorsque l'appel .UncorGor () ou .end () sera appelé.
3.Witable.end ([Chunk], [Encoding], [Rappel])
Chunk {String | Tampon} facultatif, données à écrire
Encodage {String} Encoding, si Chunk est une chaîne
rappel {fonction} facultatif, rappel après la fin du flux
Appeler écriture () après l'appel end () générera une erreur.
La copie de code est la suivante:
// Écrivez «bonjour», puis se termine par «monde!
http.createServer (fonction (req, res) {
res.write («Bonjour»);
res.end («monde!»);
// n'est plus autorisé à continuer à écrire
});