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.
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 :
Les flux offrent plusieurs avantages par rapport aux méthodes traditionnelles comme fs.readFile() ou fs.writeFile() pour la gestion des E/S :
Il existe quatre types de flux dans Node.js :
Passons en revue chaque type avec des exemples.
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.
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 :
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.
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 :
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.
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 :
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.
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 :
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.
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 :
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!