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 :
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 :
Tampon d'écriture
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.
Parmi eux, bufferToCopyTo est l'objet Buffer cible à copier. Exemple ci-dessous :
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 :
.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 :
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.