Comprendre les flux dans Node.js – Gestion efficace des données

Les flux sont une fonctionnalité puissante de Node.js qui permet de gérer efficacement de grandes quantités de données en les traitant pièce par pièce, plutôt que de tout charger en mémoire en même temps. Ils sont particulièrement utiles pour traiter des fichiers volumineux, des données en temps réel ou même des connexions réseau. Dans cet article, nous approfondirons les flux Node.js, couvrant les types de flux, comment les utiliser avec des exemples de code et un cas d'utilisation réel pour consolider votre compréhension.

Que sont les flux ?

Un flux est une séquence de données qui est traitée au fil du temps. Dans Node.js, les flux sont des instances d'EventEmitter, ce qui signifie qu'ils peuvent émettre et répondre à des événements. Les flux permettent aux données d'être lues et écrites en morceaux (petits morceaux) plutôt que de charger toutes les données en même temps, ce qui les rend plus efficaces et plus rapides en termes de mémoire.

Pourquoi utiliser les flux ?

• Utilisation efficace de la mémoire : les flux traitent les données au fur et à mesure qu'elles arrivent en morceaux, sans avoir à charger l'intégralité de l'ensemble de données en mémoire.
• Traitement plus rapide : ils commencent à traiter les données dès qu'elles sont disponibles, plutôt que d'attendre que tout se charge.
• E/S non bloquantes : étant donné que les flux fonctionnent de manière asynchrone, ils ne bloquent pas les autres opérations, ce qui les rend idéaux pour les applications en temps réel.

Types de flux

Node.js propose quatre types de flux :

1. Flux lisibles : utilisé pour lire les données de manière séquentielle.
2. Flux inscriptibles : utilisé pour écrire des données de manière séquentielle.
3. Flux duplex : peuvent être à la fois lisibles et inscriptibles.
4. Transform Streams : Un flux duplex où la sortie est une transformation de l'entrée.

Explorons chaque type de flux avec des exemples.

Flux lisibles

Un flux lisible vous permet de consommer des données, morceau par morceau, à partir d'une source telle qu'un fichier ou une requête réseau.

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

const fs = require('fs');

// Create a readable stream
const readableStream = fs.createReadStream('example.txt', 'utf8');

// Listen for 'data' events to read chunks of data
readableStream.on('data', (chunk) => {
  console.log('New chunk received:');
  console.log(chunk);
});

// Handle 'end' event when the file has been completely read
readableStream.on('end', () => {
  console.log('File reading completed.');
});

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

Explication :

• fs.createReadStream() crée un flux pour lire le contenu de example.txt.
• Le flux émet des événements « données » pour chaque morceau qu'il lit, et un événement « fin » lorsqu'il termine la lecture.

Flux inscriptibles

Les flux inscriptibles sont utilisés pour écrire des données morceau par morceau, par exemple pour enregistrer des données dans un fichier.

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

const fs = require('fs');

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

// Write chunks of data to the file
writableStream.write('First chunk of data.\n');
writableStream.write('Second chunk of data.\n');

// End the stream
writableStream.end('Final chunk of data.');

// Handle 'finish' event when writing is complete
writableStream.on('finish', () => {
  console.log('Data writing completed.');
});

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

Explication :

• fs.createWriteStream() crée un flux inscriptible à écrire dans output.txt.
• La méthode write() est utilisée pour envoyer des morceaux de données au flux. Une fois toutes les données écrites, la méthode end() est appelée, signalant la fin du flux.

Flux duplex

Les flux duplex peuvent à la fois lire et écrire des données et sont utilisés pour des opérations telles que les protocoles réseau où vous devez envoyer et recevoir des données.

Exemple : Flux duplex personnalisé

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

// Create a custom duplex stream
const myDuplexStream = new Duplex({
  read(size) {
    this.push('Reading data...');
    this.push(null);  // No more data to read
  },
  write(chunk, encoding, callback) {
    console.log(`Writing: ${chunk.toString()}`);
    callback();
  }
});

// Read from the stream
myDuplexStream.on('data', (chunk) => {
  console.log(chunk.toString());
});

// Write to the stream
myDuplexStream.write('This is a test.');
myDuplexStream.end();

Explication :

• Les flux duplex peuvent effectuer des opérations de lecture et d’écriture. Dans l'exemple, nous définissons des méthodes de lecture et d'écriture personnalisées pour le flux duplex.

Transformer les flux

Les flux de transformation vous permettent de modifier ou de transformer les données au fur et à mesure de leur passage. Il s'agit d'un type spécial de flux duplex.

Exemple : Un simple flux de transformation en texte majuscule

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

// Create a custom transform stream
const toUpperCaseTransform = new Transform({
  transform(chunk, encoding, callback) {
    this.push(chunk.toString().toUpperCase());
    callback();
  }
});

// Pipe data through the transform stream
process.stdin.pipe(toUpperCaseTransform).pipe(process.stdout);

Explication :

• Les flux de transformation prennent les entrées, les traitent (dans ce cas, en convertissant le texte en majuscules) et génèrent les données modifiées.
• Dans cet exemple, les données sont acheminées depuis l'entrée standard (process.stdin) via le flux de transformation, et le résultat est affiché vers la console (process.stdout).

Flux de tuyauterie

L'une des façons les plus courantes de travailler avec des flux est de les "rassembler". Cela signifie transmettre des données d’un flux à un autre. Ceci est utile lorsque vous devez traiter des données étape par étape, comme lire un fichier et écrire dans un autre fichier.

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

const fs = require('fs');

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

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

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

// Handle 'finish' event when piping is done
writableStream.on('finish', () => {
  console.log('File copied successfully.');
});

Explication :

• La méthode pipe() transmet les données du flux lisible (input.txt) directement au flux inscriptible (output.txt).

Cas d'utilisation réel : diffuser un téléchargement de fichiers volumineux

Dans les applications du monde réel, vous devrez peut-être télécharger des fichiers volumineux sur le serveur. Au lieu de charger l'intégralité du fichier en mémoire, vous pouvez utiliser des flux pour gérer efficacement les téléchargements de fichiers.

Exemple : Téléchargement d'un fichier à l'aide de flux avec Node.js et multer

const express = require('express');
const multer = require('multer');
const fs = require('fs');

const app = express();
const upload = multer({ dest: 'uploads/' });

app.post('/upload', upload.single('file'), (req, res) => {
  const readableStream = fs.createReadStream(req.file.path);
  const writableStream = fs.createWriteStream(`./uploads/${req.file.originalname}`);

  // Pipe the uploaded file to the writable stream
  readableStream.pipe(writableStream);

  writableStream.on('finish', () => {
    res.send('File uploaded and saved.');
  });

  writableStream.on('error', (err) => {
    res.status(500).send('Error saving file.');
  });
});

app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

Explanation:

• We use multer to handle file uploads. When the file is uploaded, it is piped from a temporary location to the desired directory on the server.
• This method is efficient as it streams the file data instead of holding it all in memory at once.

Best Practices for Working with Streams

1. Error Handling: Always handle errors in streams to avoid unhandled exceptions, especially when dealing with file systems or network operations.

Example:

   readableStream.on('error', (err) => {
     console.error('Stream error:', err.message);
   });

1. Flow Control: Be mindful of flow control when reading and writing data, as writable streams can become overwhelmed if data is being written faster than it can be consumed.

Example:

   writableStream.write(chunk, (err) => {
     if (err) console.error('Error writing chunk:', err.message);
   });

1. Use Pipe for Simplicity: When transferring data between streams, always prefer using pipe() instead of manually managing the flow of data.

Conclusion

Streams in Node.js offer a powerful and efficient way to handle data, especially in cases where data comes in large quantities or needs to be processed incrementally. From reading and writing files to handling network requests and processing data in real time, streams allow you to build scalable and performant applications. In this article, we explored the different types of streams, how to use them, and real-world use cases to deepen your understanding of stream-based processing in Node.js.

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!