Guide complet des flux dans Node.js

Les flux dans Node.js sont un moyen puissant de gérer la lecture et l'écriture de données de manière continue. Ils vous permettent de traiter les données efficacement, notamment lorsque vous traitez de grandes quantités d'informations ou d'opérations d'E/S. Ce guide couvrira les types de flux, comment les utiliser et des exemples pratiques pour vous aider à comprendre comment les flux fonctionnent dans Node.js.

Que sont les flux ?

Les flux sont des objets qui vous permettent de lire des données à partir d'une source ou d'écrire des données vers une destination de manière continue. Ils sont idéaux pour traiter les données pièce par pièce plutôt que de lire ou d'écrire des fichiers ou des tampons entiers en même temps. Ceci est particulièrement utile lorsque vous travaillez avec de grands ensembles de données, car cela peut réduire considérablement l'utilisation de la mémoire.

Concepts clés

• Mode fluide : les données circulent automatiquement de la source à la destination.
• Mode pause : les données doivent être lues manuellement à partir de la source.
• Flux lisibles : flux à partir desquels vous pouvez lire des données.
• Flux inscriptibles : flux dans lesquels vous pouvez écrire des données.
• Flux duplex : flux pouvant à la fois lire et écrire des données.
• Transform Streams : flux qui modifient ou transforment les données au fur et à mesure de leur lecture ou de leur écriture.

Types de flux

1. Flux lisibles : ces flux vous permettent de lire des données. Les exemples incluent fs.createReadStream() et http.IncomingMessage.

2. Flux inscriptibles : ces flux vous permettent d'écrire des données. Les exemples incluent fs.createWriteStream() et http.ServerResponse.

3. Flux duplex : ces flux peuvent lire et écrire des données. Les exemples incluent les sockets TCP et net.Duplex.

4. Transform Streams : il s'agit d'un type de flux duplex qui peut modifier les données lors de leur lecture ou de leur écriture. Les exemples incluent zlib.createGzip() pour la compression.

Création de flux lisibles

Vous pouvez créer un flux lisible à l'aide du module fs intégré pour lire des fichiers ou en utilisant stream.Readable pour créer des flux lisibles personnalisés.

Exemple : lecture d'un fichier avec un flux lisible

const fs = require('fs');

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

// Handling the 'data' event
readableStream.on('data', (chunk) => {
    console.log('New chunk received:', chunk);
});

// Handling the 'end' event
readableStream.on('end', () => {
    console.log('No more data to read.');
});

Exemple : flux lisible personnalisé

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

class MyReadableStream extends Readable {
    constructor(options) {
        super(options);
        this.current = 0;
    }

    _read(size) {
        if (this.current  {
    console.log('Received:', chunk.toString());
});

Création de flux inscriptibles

Vous pouvez créer des flux inscriptibles à l'aide du module fs ou en étendant la classe stream.Writable.

Exemple : écriture dans un fichier avec un flux inscriptible

const fs = require('fs');

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

// Write data to the stream
writableStream.write('Hello, World!\n');
writableStream.write('Writing to a file using streams.\n');

// End the stream
writableStream.end(() => {
    console.log('Finished writing to file.');
});

Exemple : flux inscriptible personnalisé

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

class MyWritableStream extends Writable {
    _write(chunk, encoding, callback) {
        console.log('Writing:', chunk.toString());
        callback(); // Call when done
    }
}

const myWritableStream = new MyWritableStream();
myWritableStream.write('Hello, World!\n');
myWritableStream.write('Writing to custom writable stream.\n');
myWritableStream.end();

Utilisation de flux duplex

Les flux duplex peuvent lire et écrire des données simultanément. Un cas d'utilisation courant est celui des sockets TCP.

Exemple : création d'un flux duplex

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

class MyDuplexStream extends Duplex {
    _read(size) {
        this.push('Data from duplex stream\n');
        this.push(null); // No more data
    }

    _write(chunk, encoding, callback) {
        console.log('Received:', chunk.toString());
        callback();
    }
}

const myDuplexStream = new MyDuplexStream();
myDuplexStream.on('data', (chunk) => {
    console.log('Reading:', chunk.toString());
});

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

Utilisation des flux de transformation

Les flux de transformation sont utiles pour modifier les données au fur et à mesure qu'elles circulent dans le flux. Par exemple, vous pouvez utiliser un flux de transformation pour compresser les données.

Exemple : création d'un flux de transformation

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

class MyTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        const upperChunk = chunk.toString().toUpperCase();
        this.push(upperChunk);
        callback();
    }
}

const myTransformStream = new MyTransformStream();
myTransformStream.on('data', (chunk) => {
    console.log('Transformed:', chunk.toString());
});

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

Flux de tuyauterie

L'une des fonctionnalités puissantes des flux est la possibilité de les regrouper. Piping vous permet de connecter un flux lisible à un flux inscriptible, ce qui facilite le transfert de données.

Exemple : flux de tuyauterie

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 to the writable stream
readableStream.pipe(writableStream);

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

Diffuser des événements dans Node.js

1. Événements de flux lisibles

Les flux lisibles émettent plusieurs événements importants qui vous aident à gérer le flux de données :

• data : émis lorsqu'un bloc de données est disponible pour être lu.
• end : émis lorsqu'il n'y a plus de données à lire.
• erreur : émis lorsqu'une erreur se produit lors de la lecture.
• close : émis lorsque le flux et toutes les ressources sous-jacentes (comme les descripteurs de fichiers) ont été fermés.

Exemple : événements de flux lisibles

const fs = require('fs');

const readableStream = fs.createReadStream('example.txt');

readableStream.on('data', (chunk) => {
    console.log('Received chunk:', chunk.toString());
});

readableStream.on('end', () => {
    console.log('No more data to read.');
});

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

readableStream.on('close', () => {
    console.log('Stream closed.');
});

2. Événements de flux inscriptibles

Les flux inscriptibles émettent également plusieurs événements :

• drain : émis lorsque le flux est prêt à accepter plus de données après avoir été plein.
• finish : émis lorsque toutes les données ont été écrites dans le flux et que la méthode end() a été appelée.
• error : émis lorsqu'une erreur se produit lors de l'écriture.
• close : émis lorsque le flux et toutes les ressources sous-jacentes ont été fermés.

Exemple : événements de flux inscriptibles

const fs = require('fs');

const writableStream = fs.createWriteStream('output.txt');

writableStream.on('finish', () => {
    console.log('All data has been written to output.txt');
});

writableStream.on('error', (err) => {
    console.error('Error occurred:', err);
});

// Writing data
writableStream.write('Hello, World!\n');
writableStream.write('Writing to a file using streams.\n');
writableStream.end(); // Call end to finish the writing process

3. Transformer les événements de flux

Les flux de transformation héritent des événements des flux lisibles et inscriptibles, et ils émettent :

• data : émis lorsqu'un morceau transformé est disponible en lecture.
• end : émis lorsqu'il n'y a plus de données à transformer.
• error : émis lorsqu'une erreur se produit lors de la transformation.
• finish : émis lorsque toutes les données ont été traitées et écrites.

Exemple : Transformer les événements de flux

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

class MyTransformStream extends Transform {
    _transform(chunk, encoding, callback) {
        const upperChunk = chunk.toString().toUpperCase();
        this.push(upperChunk);
        callback();
    }
}

const myTransformStream = new MyTransformStream();

myTransformStream.on('data', (chunk) => {
    console.log('Transformed chunk:', chunk.toString());
});

myTransformStream.on('end', () => {
    console.log('No more data to transform.');
});

myTransformStream.on('error', (err) => {
    console.error('Error occurred:', err);
});

// Write data to the transform stream
myTransformStream.write('Hello, World!\n');
myTransformStream.write('Transforming this text.\n');
myTransformStream.end(); // End the stream

Résumé des événements

• Flux lisibles : données, fin, erreur, fermeture
• Flux inscriptibles : vidange, fin, erreur, fermeture
• Transformer les flux : hérite des données, de la fin, de l'erreur et de la fin des flux lisibles et inscriptibles

Conclusion

Les flux dans Node.js offrent un moyen puissant et efficace de gérer les données de manière continue. Ils vous permettent de lire et d'écrire des données pièce par pièce, ce qui les rend particulièrement utiles pour les opérations d'E/S et pour travailler avec de grands ensembles de données. Comprendre comment créer et utiliser différents types de flux, ainsi que comment gérer les événements, vous aidera à créer des applications plus efficaces et évolutives dans Node.js.

Que vous créiez des flux lisibles, inscriptibles, duplex ou de transformation, la flexibilité de l'API de flux vous permet de gérer le traitement des données de la manière la mieux adaptée aux besoins de votre application.