Les bases des flux Node.js

Node.js, étant asynchrone et axé sur l'événement, excelle aux opérations liées aux E / S. Tirer parti de Node.js Streams simplifie considérablement ces tâches en traitant efficacement les données dans des morceaux plus petits. Plongeons dans le monde des flux et voyons comment ils rationalisent les E / S.

Concepts clés:

• Node.js Streams, Asynchrone et axé sur l'événement, Optimiser les E / S en gérant les données dans des parties gérables.
• Les flux sont classés comme lisibles, écrivains ou duplex (à la fois lisibles et écrivains). Les flux lisibles récupérent les données d'une source; Les flux écrivains envoient des données à une destination.
• La fonction pipe() est inestimable, facilitant le transfert de données transparente entre la source et la destination sans gestion manuelle du flux.
• Des méthodes comme Readable.pause(), Readable.resume() et readable.unpipe() offrent un contrôle granulaire sur le flux de données, améliorant les fonctionnalités du flux.

Comprendre les flux:

Les flux sont analogues aux tuyaux Unix, permettant le transfert de données sans effort de la source à la destination. Essentiellement, un flux est un EventEmitter avec des méthodes spécialisées. Les méthodes implémentées déterminent si un flux est lisible, écrivative ou duplex. Les flux lisibles fournissent une entrée de données; Les flux écrivables gèrent la sortie des données.

Vous avez probablement déjà rencontré des flux dans Node.js. Dans un serveur HTTP, la demande est un flux lisible et la réponse est un flux écrivative. Le module fs fournit des capacités de flux de fichiers lisibles et écrites.

Cet article se concentre sur des flux lisibles et écrivains; Les flux duplex dépassent sa portée.

Streams lisibles:

Un flux lisible lit les données d'une source (un fichier, un tampon en mémoire ou un autre flux). Étant EventEmitter s, ils déclenchent divers événements. Nous utilisons ces événements pour interagir avec les flux.

Lire des flux:

L'approche la plus courante consiste à écouter l'événement data et à attacher un rappel. Lorsque des données sont disponibles, l'événement data tire, exécutant le rappel.

<code class="language-javascript">const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');
let data = '';
readableStream.on('data', (chunk) => { data += chunk; });
readableStream.on('end', () => { console.log(data); });</code>

fs.createReadStream() crée un flux lisible. Initialement statique, il commence à couler lors de la connexion d'un auditeur d'événements data. Les morceaux de données sont ensuite transmis au rappel. La fréquence des événements data est déterminée par l'implémentation du flux (par exemple, une demande HTTP pourrait émettre un événement par quelques KB, tandis qu'un flux de fichiers peut émettre par ligne).

L'événement end signale la fin des données.

Alternativement, appelez à plusieurs reprises read() sur l'instance de flux jusqu'à ce que toutes les données soient lues:

<code class="language-javascript">const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');
let data = '';
readableStream.on('data', (chunk) => { data += chunk; });
readableStream.on('end', () => { console.log(data); });</code>

read() récupère les données du tampon interne. Il renvoie null quand il n'y a pas de données. L'événement readable indique la disponibilité des données.

Réglage du codage:

Les données

est généralement un objet Buffer. Pour les chaînes, utilisez Readable.setEncoding():

<code class="language-javascript">const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');
let data = '';
let chunk;
readableStream.on('readable', () => {
  while ((chunk = readableStream.read()) !== null) {
    data += chunk;
  }
});
readableStream.on('end', () => { console.log(data); });</code>

Cela interprète les données comme UTF-8, en les faisant passer sous forme de chaîne au rappel.

Piping:

La tuyauterie simplifie le transfert de données entre la source et la destination:

<code class="language-javascript">const fs = require('fs');
const readableStream = fs.createReadStream('file.txt');
let data = '';
readableStream.setEncoding('utf8');
readableStream.on('data', (chunk) => { data += chunk; });
readableStream.on('end', () => { console.log(data); });</code>

pipe() gère automatiquement le flux de données.

Chaîne:

Les flux peuvent être enchaînés:

<code class="language-javascript">const fs = require('fs');
const readableStream = fs.createReadStream('file1.txt');
const writableStream = fs.createWriteStream('file2.txt');
readableStream.pipe(writableStream);</code>

Cela décompresse input.txt.gz et écrit le résultat à output.txt.

Méthodes de flux lisibles supplémentaires:

• Readable.pause(): USE le flux.
• Readable.resume(): reprend un flux en pause.
• readable.unpipe(): supprime les flux de destination du tuyau.

Streams écrit:

Les flux écrivables envoient des données à une destination. Comme les flux lisibles, ils sont EventEmitter s.

Écriture dans les flux:

Utilisez write() pour envoyer des données:

<code class="language-javascript">const fs = require('fs');
const zlib = require('zlib');
fs.createReadStream('input.txt.gz')
  .pipe(zlib.createGunzip())
  .pipe(fs.createWriteStream('output.txt'));</code>

write() Renvoie un booléen indiquant le succès. Si faux, le flux est temporairement plein; Attendez l'événement drain avant d'écrire plus.

Fin des données:

Appelez end() pour signaler la fin des données. L'événement finish est émis une fois que toutes les données sont rincées. Vous ne pouvez pas écrire après avoir appelé end().

Événements de flux écrite importants:

• error: indique une erreur.
• pipe: émis lorsqu'un flux lisible est tuyau.
• unpipe: émis lorsque unpipe() est appelé sur le flux lisible.

Conclusion:

Les flux sont une caractéristique puissante de Node.js, améliorant l'efficacité des E / S. La compréhension des flux, de la tuyauterie et du chaînage permet d'écrire un code propre et performant.

Node.js Streams FAQ:

• Quels sont les flux Node.js? Ce sont des objets qui permettent un traitement incrémentiel efficace des données, en évitant de charger des ensembles de données entiers dans la mémoire.

• Types principaux de flux Node.js? Lisible, écrivable, duplex et transformée.

• Création d'un flux lisible? Utilisez stream.Readable et implémentez la méthode _read.

• Cas d'utilisation courants pour les flux lisibles? Lire les fichiers volumineux, le traitement des données à partir des demandes HTTP, la manipulation des données en temps réel.

• Création d'un flux écrit? Utilisez stream.Writable et implémentez la méthode _write.

• Utilisations courantes des flux écrivains? Enregistrer des données dans les fichiers, en envoyant des données aux services.

• Stream duplex? combine des fonctionnalités lisibles et écrit.

• Transformer les flux? Modifier les données au fur et à mesure de leur passage (par exemple, compression, chiffrement).

• Données de tuyauterie entre les flux? Utilisez la méthode .pipe().

• Best Practices pour travailler avec Node.js Streams? Utilisez-les pour de grands ensembles de données, gérez les erreurs et la contre-pression, et considérez util.promisify pour les opérations basées sur les promesses.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!