Dans cet article, nous allons approfondir les Node.js Streams et comprendre comment ils aident à traiter efficacement de grandes quantités de données. Les flux constituent un moyen élégant de gérer des ensembles de données volumineux, tels que la lecture de fichiers volumineux, le transfert de données sur le réseau ou le traitement d'informations en temps réel. Contrairement aux opérations d'E/S traditionnelles qui lisent ou écrivent l'intégralité des données en même temps, les flux divisent les données en morceaux gérables et les traitent pièce par pièce, permettant une utilisation efficace de la mémoire.
Dans cet article, nous aborderons :
Un flux dans Node.js est un flux continu de données. Les flux sont particulièrement utiles pour gérer les tâches liées aux E/S, telles que la lecture de fichiers, la communication sur un réseau ou l'interaction avec des bases de données. Au lieu d'attendre la fin d'une opération complète, les flux permettent de traiter les données par morceaux.
Node.js propose quatre types de flux :
Explorons chaque type de flux avec des exemples.
Flux lisibles vous permettent de lire les données pièce par pièce, ce qui est utile pour gérer des fichiers volumineux ou des sources de données en temps réel.
const fs = require('fs');
// Create a readable stream from a large file
const readableStream = fs.createReadStream('largeFile.txt', {
encoding: 'utf8',
highWaterMark: 16 * 1024 // 16 KB chunk size
});
readableStream.on('data', (chunk) => {
console.log('New chunk received:', chunk);
});
readableStream.on('end', () => {
console.log('Reading file completed');
});
Les flux inscriptibles sont utilisés pour écrire des données de manière incrémentielle vers une destination, telle qu'un fichier ou une socket réseau.
const fs = require('fs');
// Create a writable stream to write data to a file
const writableStream = fs.createWriteStream('output.txt');
writableStream.write('Hello, world!\n');
writableStream.write('Writing data chunk by chunk.\n');
// End the stream and close the file
writableStream.end(() => {
console.log('File writing completed');
});
Un flux duplex peut lire et écrire des données. Un exemple courant est un socket TCP, qui peut envoyer et recevoir des données simultanément.
const net = require('net');
// Create a duplex stream (a simple echo server)
const server = net.createServer((socket) => {
socket.on('data', (data) => {
console.log('Received:', data.toString());
// Echo the data back to the client
socket.write(`Echo: ${data}`);
});
socket.on('end', () => {
console.log('Connection closed');
});
});
server.listen(8080, () => {
console.log('Server listening on port 8080');
});
Un flux de transformation est un type spécial de flux duplex qui modifie les données lors de leur passage. Un cas d'utilisation courant est la compression de fichiers.
const fs = require('fs');
const zlib = require('zlib');
// Create a readable stream for a file and a writable stream for the output file
const readable = fs.createReadStream('input.txt');
const writable = fs.createWriteStream('input.txt.gz');
// Create a transform stream that compresses the file
const gzip = zlib.createGzip();
// Pipe the readable stream into the transform stream, then into the writable stream
readable.pipe(gzip).pipe(writable);
writable.on('finish', () => {
console.log('File successfully compressed');
});
Lorsque vous traitez des fichiers volumineux (par exemple, des journaux ou des médias), le chargement de l'intégralité du fichier en mémoire est inefficace et peut entraîner des problèmes de performances. Les flux vous permettent de lire ou d'écrire des fichiers volumineux de manière incrémentielle, réduisant ainsi la charge sur la mémoire.
Exemple :
Les applications en temps réel telles que les serveurs de chat ou les tableaux de bord en direct doivent traiter les données dès leur arrivée. Les flux fournissent un moyen de gérer ces données efficacement, réduisant ainsi la latence.
Exemple :
La compression est un autre cas d'utilisation courant pour les flux. Au lieu de charger l'intégralité du fichier en mémoire, vous pouvez compresser les données à la volée à l'aide de flux de transformation.
Exemple :
Les flux Node.js offrent un moyen flexible et efficace de gérer de grandes quantités de données, que vous lisiez des fichiers, traitiez des requêtes réseau ou effectuiez des opérations en temps réel. En décomposant les données en morceaux gérables, les flux vous permettent de travailler avec de grands ensembles de données sans surcharger la mémoire du système.
Dans le prochain article, nous explorerons NGINX et son rôle dans la diffusion de contenu statique, l'équilibrage de charge et le travail en tant que proxy inverse dans les applications Node.js. Nous discuterons également de la façon d’intégrer SSL et le cryptage pour une sécurité renforcée.
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!
MySQL crée une procédure stockée
Méthode d'implémentation de la fonction js barrage
Comment résoudre le rapport d'erreur
Comment résoudre l'erreur 443
configuration des variables d'environnement jdk
Que signifient les faces B et C ?
horodatage python
Comment changer la disposition CAO du blanc au noir
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
