Comprendre les flux Node.js : quoi, pourquoi et comment les utiliser

Les flux Node.js sont une fonctionnalité essentielle pour gérer efficacement de grandes quantités de données. Contrairement aux mécanismes d'entrée-sortie traditionnels, les flux permettent de traiter les données par morceaux plutôt que de charger l'intégralité des données en mémoire, ce qui les rend parfaits pour traiter des fichiers volumineux ou des données en temps réel. Dans cet article, nous approfondirons ce que sont les flux Node.js, pourquoi ils sont utiles, comment les implémenter et différents types de flux avec des exemples détaillés et des cas d'utilisation.

Que sont les flux Node.js ?

En termes simples, un flux est une séquence de données déplacées d'un point à un autre au fil du temps. Vous pouvez le considérer comme un tapis roulant où les données circulent pièce par pièce au lieu d'être toutes en même temps.

Les flux Node.js fonctionnent de la même manière ; ils vous permettent de lire et d'écrire des données par morceaux (au lieu de toutes en même temps), ce qui les rend très efficaces en termes de mémoire.

Les flux dans Node.js sont construits sur EventEmitter, ce qui les rend pilotés par les événements. Quelques événements importants incluent :

• data : émis lorsque les données sont disponibles pour la consommation.
• end : émis lorsqu'il n'y a plus de données disponibles à consommer.
• error : Émis lorsqu'une erreur se produit lors de la lecture ou de l'écriture.

Pourquoi utiliser les flux ?

Les flux offrent plusieurs avantages par rapport aux méthodes traditionnelles comme fs.readFile() ou fs.writeFile() pour la gestion des E/S :

1. Efficacité de la mémoire : vous pouvez gérer des fichiers très volumineux sans consommer de grandes quantités de mémoire, car les données sont traitées par morceaux.
2. Performances : les flux fournissent des E/S non bloquantes. Ils permettent de lire ou d'écrire des données pièce par pièce sans attendre la fin de l'opération complète, ce qui rend le programme plus réactif.
3. Traitement des données en temps réel : les flux permettent le traitement de données en temps réel telles que la vidéo/l'audio en direct ou de grands ensembles de données provenant d'API.

Types de flux dans Node.js

Il existe quatre types de flux dans Node.js :

1. Flux lisibles : pour lire les données.
2. Flux inscriptibles : pour écrire des données.
3. Flux duplex : flux pouvant lire et écrire des données simultanément.
4. Transform Streams : un type de flux duplex où la sortie est une version modifiée de l'entrée (par exemple, compression de données).

Passons en revue chaque type avec des exemples.

1. Flux lisibles

Les flux lisibles sont utilisés pour lire les données morceau par morceau. Par exemple, lors de la lecture d'un fichier volumineux, l'utilisation d'un flux lisible nous permet de lire de petits morceaux de données en mémoire au lieu de charger l'intégralité du fichier.

Exemple : lecture d'un fichier à l'aide d'un flux lisible

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('largefile.txt', { encoding: 'utf8' });

// Listen for data events and process chunks
readableStream.on('data', (chunk) => {
  console.log('Chunk received:', chunk);
});

// Listen for the end event when no more data is available
readableStream.on('end', () => {
  console.log('No more data.');
});

// Handle error event
readableStream.on('error', (err) => {
  console.error('Error reading the file:', err);
});

Explication :

• fs.createReadStream() crée un flux pour lire le fichier en morceaux.
• L'événement data est déclenché à chaque fois qu'un morceau est prêt, et l'événement end est déclenché lorsqu'il n'y a plus de données à lire.

2. Flux inscriptibles

Les flux inscriptibles sont utilisés pour écrire des données morceau par morceau. Au lieu d'écrire toutes les données en même temps, vous pouvez les diffuser dans un fichier ou une autre destination inscriptible.

Exemple : écriture de données à l'aide d'un flux inscriptible

const fs = require('fs');

// Create a writable stream
const writableStream = fs.createWriteStream('output.txt');

// Write chunks to the writable stream
writableStream.write('Hello, World!\n');
writableStream.write('Streaming data...\n');

// End the stream (important to avoid hanging the process)
writableStream.end('Done writing.\n');

// Listen for the finish event
writableStream.on('finish', () => {
  console.log('Data has been written to output.txt');
});

// Handle error event
writableStream.on('error', (err) => {
  console.error('Error writing to the file:', err);
});

Explication :

• fs.createWriteStream() crée un flux inscriptible.
• Les données sont écrites dans le flux à l'aide de la méthode write().
• L'événement finish est déclenché lorsque toutes les données sont écrites et la méthode end() marque la fin du flux.

3. Flux duplex

Les flux duplex peuvent à la fois lire et écrire des données. Un exemple typique de flux duplex est une prise réseau, où vous pouvez envoyer et recevoir des données simultanément.

Exemple : flux duplex

const { Duplex } = require('stream');

const duplexStream = new Duplex({
  write(chunk, encoding, callback) {
    console.log(`Writing: ${chunk.toString()}`);
    callback();
  },
  read(size) {
    this.push('More data');
    this.push(null);  // End the stream
  }
});

// Write to the duplex stream
duplexStream.write('Hello Duplex!\n');

// Read from the duplex stream
duplexStream.on('data', (chunk) => {
  console.log(`Read: ${chunk}`);
});

Explication :

• Nous définissons une méthode write pour l'écriture et une méthode read pour la lecture.
• Les flux duplex peuvent gérer simultanément la lecture et l'écriture.

4. Transformer les flux

Les flux de transformation modifient les données lors de leur passage dans le flux. Par exemple, un flux de transformation pourrait compresser, chiffrer ou manipuler des données.

Exemple : flux de transformation (texte en majuscules)

const { Transform } = require('stream');

// Create a transform stream that converts data to uppercase
const transformStream = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

// Pipe input to transform stream and then output the result
process.stdin.pipe(transformStream).pipe(process.stdout);

Explication :

• Les données saisies depuis stdin sont transformées en majuscules par la méthode de transformation, puis sorties vers stdout.

Flux de tuyauterie

L'une des fonctionnalités clés des flux Node.js est leur capacité à être diffusées. Le piping vous permet d'enchaîner des flux ensemble, en passant la sortie d'un flux comme entrée d'un autre.

Exemple : transférer un flux lisible vers un flux inscriptible

const fs = require('fs');

// Create a readable stream for the input file
const readableStream = fs.createReadStream('input.txt');

// Create a writable stream for the output file
const writableStream = fs.createWriteStream('output.txt');

// Pipe the readable stream into the writable stream
readableStream.pipe(writableStream);

// Handle errors
readableStream.on('error', (err) => console.error('Read error:', err));
writableStream.on('error', (err) => console.error('Write error:', err));

Explication :

• Kaedah pipe() menghubungkan strim boleh dibaca ke strim boleh tulis, menghantar potongan data terus dari input.txt ke output.txt.

Kes Penggunaan Praktikal Aliran Node.js

1. Membaca dan Menulis Fail Besar: Daripada membaca keseluruhan fail ke dalam memori, strim membenarkan anda memproses fail dalam ketulan kecil.
2. Pemprosesan Data Masa Nyata: Strim sesuai untuk aplikasi masa nyata seperti pemprosesan audio/video, aplikasi sembang atau suapan data langsung.
3. Permintaan/Respons HTTP: Permintaan dan respons HTTP dalam Node.js ialah strim, menjadikannya mudah untuk memproses data masuk atau menghantar data secara progresif.

Kesimpulan

Strim Node.js menyediakan cara yang berkuasa dan cekap untuk mengendalikan operasi I/O dengan bekerja dengan data dalam ketulan. Sama ada anda membaca fail yang besar, menyalurkan data antara sumber atau menukar data dengan cepat, strim menawarkan penyelesaian yang cekap memori dan berprestasi. Memahami cara memanfaatkan strim yang boleh dibaca, boleh ditulis, dupleks dan mengubah strim dalam aplikasi anda boleh meningkatkan prestasi dan kebolehskalaan aplikasi anda dengan ketara.

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!