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.
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 en termes de mémoire et plus rapides.
Node.js propose quatre types de flux :
Explorons chaque type de flux avec des exemples.
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 :
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 :
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 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 :
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 :
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:
Example:
readableStream.on('error', (err) => {
console.error('Stream error:', err.message);
});
Example:
writableStream.write(chunk, (err) => {
if (err) console.error('Error writing chunk:', err.message);
});
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.
以上是了解 Node.js 中的流 — 高效的数据处理的详细内容。更多信息请关注PHP中文网其他相关文章！
