Tutoriel Node js Streams: Filestream, Pipes

Dans ce tutoriel, vous apprendrez

Filestream dans Node.js
Tuyaux dans Node.js
Événements dans Node.js
Événements émetteurs

Filestream dans Node.js

Node utilise largement les flux comme mécanisme de transfert de données.

Par exemple, lorsque vous exportez quelque chose vers la console à l'aide de la fonction console.log, vous utilisez en fait un flux pour envoyer les données à la console.

Node.js a également la capacité de diffuser des données à partir de fichiers afin qu'ils puissent être lus et écrits de manière appropriée. Nous allons maintenant regarder un exemple de la façon dont nous pouvons utiliser des flux pour lire et écrire à partir de fichiers. Nous devons suivre les étapes mentionnées ci-dessous pour cet exemple

Étape 1) Créez un fichier appelé data.txt contenant les données ci-dessous. Supposons que ce fichier soit stocké sur le lecteur D de notre machine locale.

Tutoriel sur Node.js

introduction

Événements

Générateurs

Connectivité des données

Utiliser Jasmine

Étape 2) Écrivez le code pertinent qui utilisera les flux pour lire les données du fichier.

var fs = require("fs");var stream;stream = fs.createReadStream("D://data.txt");stream.on("data", function(data) {var chunk = data.toString();console.log(chunk);});

Explication du code: -

Nous devons d'abord inclure les modules 'fs' qui contiennent toutes les fonctionnalités requises pour créer des flux.
Ensuite, nous créons un flux lisible en utilisant la méthode - createReadStream. En entrée, nous donnons l'emplacement de notre fichier data.txt.
La fonction steam.on est un gestionnaire d'événements et dans celui-ci, nous spécifions le premier paramètre comme «données». Cela signifie que chaque fois que des données arrivent dans le flux à partir du fichier, exécutez une fonction de rappel. Dans notre cas, nous définissons une fonction de rappel qui effectuera 2 étapes de base. La première consiste à convertir les données lues dans le fichier sous forme de chaîne. La seconde serait d'envoyer la chaîne convertie en tant que sortie à la console.
Nous prenons chaque morceau de données qui est lu à partir du flux de données et le convertissons en une chaîne.
Enfin, nous envoyons la sortie de chaque morceau converti de chaîne à la console.

Production:

Si le code est exécuté correctement, vous verrez la sortie ci-dessus dans la console. Cette sortie sera la même que celle du fichier data.txt.

Ecrire dans un fichier

De la même manière, que nous créons un flux de lecture, nous pouvons également créer un flux d'écriture pour écrire des données dans un fichier. Créons d'abord un fichier vide sans contenu appelé data.txt. Supposons que ce fichier soit placé dans le lecteur D de notre ordinateur.

Le code ci-dessous montre comment nous pouvons écrire des données dans le fichier.

var fs = require("fs");var stream;stream = fs.createWriteStream("D://data.txt");stream.write("Tutorial on Node.js")stream.write("Introduction")stream.write("Events")stream.write("Generators")stream.write("Data Connectivity")stream.write("Using Jasmine")

Explication du code: -

Nous créons un flux accessible en écriture en utilisant la méthode - createWriteStream. En entrée, nous donnons l'emplacement de notre fichier data.txt.
Ensuite, nous avons utilisé la méthode stream.write pour écrire les différentes lignes de texte dans notre fichier texte. Le flux se chargera d'écrire ces données dans le fichier data.txt.

Si vous ouvrez le fichier data.txt, vous verrez maintenant les données suivantes dans le fichier

Tutoriel sur Node.js

introduction

Événements

Générateurs

Connectivité des données

Utiliser Jasmine

Tuyaux dans Node.js

Dans les applications Node, les flux peuvent être acheminés ensemble à l'aide de la méthode pipe (), qui prend deux arguments:

Un flux inscriptible requis qui sert de destination pour les données et
Un objet optionnel utilisé pour passer des options.

Un exemple typique d'utilisation de tuyaux, si vous souhaitez transférer des données d'un fichier à l'autre.

Voyons donc un exemple de la façon dont nous pouvons transférer des données d'un fichier à l'autre à l'aide de tuyaux.

Étape 1) Créez un fichier appelé datainput.txt contenant les données ci-dessous. Supposons que ce fichier soit stocké sur le lecteur D de notre machine locale.

Tutoriel sur Node.js

introduction

Événements

Générateurs

Connectivité des données

Utiliser Jasmine

Étape 2) Créez un fichier vide vide appelé dataOutput.txt et placez-le sur le lecteur D de votre machine locale.

Étape 3) Écrivez le code ci-dessous pour effectuer le transfert des données du fichier datainput.txt vers le fichier dataOutput.txt.

var fs = require("fs");var readStream = fs.createReadStream("D://datainput.txt");var writeStream = fs.createWriteStream("D://dataOutput.txt");readStream.pipe(writeStream);

Explication du code: -

Nous créons d'abord un "readstream" vers notre fichier datainput.txt qui contient toutes nos données qui doivent être transférées vers le nouveau fichier.
Nous devons ensuite créer un "writestream" dans notre fichier dataOutput.txt, qui est notre fichier vide et est la destination pour le transfert des données à partir du fichier datainput.txt.
Nous utilisons ensuite la commande pipe pour transférer les données du flux de lecture vers le flux d'écriture. La commande pipe prendra toutes les données qui entrent dans le flux de lecture et les poussera vers le flux d'écriture.

Si vous ouvrez maintenant le fichier dataOutput.txt, vous verrez toutes les données qui étaient présentes dans le fichier datainput.txt.

Événements dans Node.js

Les événements sont l'un des concepts clés de Node.js et parfois Node.js est appelé infrastructure pilotée par les événements.

Fondamentalement, un événement est quelque chose qui se produit. Par exemple, si une connexion est établie à une base de données, l'événement de connexion à la base de données est déclenché. La programmation événementielle consiste à créer des fonctions qui seront déclenchées lorsque des événements spécifiques sont déclenchés.

Regardons un exemple de base de définition d'un événement dans Node.js.

Nous allons créer un événement appelé 'data_received'. Lorsque cet événement est déclenché, le texte «données reçues» sera envoyé à la console.

var events = require('events');var eventEmitter = new events.EventEmitter();eventEmitter.on('data_received', function() {console.log('data received succesfully.');});eventEmitter.emit('data_received');

Explication du code: -

Utilisez la fonction require pour inclure le module «événements». Avec ce module, vous pourrez créer des événements dans Node.js.
Créez un nouvel émetteur d'événements. Ceci est utilisé pour lier l'événement, qui dans notre cas est "data_received" à une fonction de rappel qui est définie à l'étape 3.
Nous définissons une fonction événementielle qui dit que si dans le cas où l'événement "data_received" est déclenché, nous devons envoyer le texte "data_received" à la console.
Enfin, nous avons un déclencheur manuel de notre événement à l'aide de la fonction eventEmiter.emit. Cela déclenchera l'événement data_received.

Lorsque le programme est exécuté, le texte «données reçues» sera envoyé à la console comme indiqué ci-dessous.

Événements émetteurs

Lors de la définition des événements, il existe différentes méthodes pour les événements qui peuvent être appelées. Ce sujet se concentre sur l'examen de chacun d'eux en détail.

Gestionnaires d'événements ponctuels

Parfois, vous pouvez être intéressé à réagir à un événement uniquement la première fois qu'il se produit. Dans ces situations, vous pouvez utiliser la méthode once ().

Voyons comment nous pouvons utiliser la méthode once pour les gestionnaires d'événements.

Explication du code: -

Ici, nous utilisons la méthode 'once' pour dire que pour l'événement 'data_received', la fonction de rappel ne doit être exécutée qu'une seule fois.
Ici, nous déclenchons manuellement l'événement 'data_received'.
Lorsque l'événement 'data_received' est à nouveau déclenché, cette fois, rien ne se passera. C'est à cause de la première étape où nous avons dit que l'événement ne pouvait être déclenché qu'une seule fois.

Si le code est exécuté correctement, la sortie du journal sera «data_received successfully». Ce message n'apparaîtra qu'une seule fois dans la console.

Inspection des écouteurs d'événements

À tout moment de sa vie, un émetteur d'événement peut avoir zéro ou plusieurs écouteurs qui lui sont attachés. Les écouteurs de chaque type d'événement peuvent être inspectés de plusieurs manières.

Si vous souhaitez uniquement déterminer le nombre d'écouteurs attachés, ne cherchez pas plus loin que la méthode EventEmitter.listenerCount ().

( Remarque: les auditeurs sont importants car le programme principal doit savoir si des auditeurs sont ajoutés à la volée à un événement, sinon le programme fonctionnera mal car des auditeurs supplémentaires seront appelés.)

Explication du code: -

Nous définissons un type eventEmitter qui est requis pour l'utilisation des méthodes liées aux événements.
Nous définissons alors un objet appelé émetteur qui sera utilisé pour définir nos gestionnaires d'événements.
Nous créons 2 gestionnaires d'événements qui ne font fondamentalement rien. Ceci est simple pour notre exemple juste pour montrer comment la méthode listenerCount fonctionne.
Désormais, lorsque vous invoquez la méthode listenerCount sur notre événement data_received, elle enverra le nombre d'écouteurs d'événements attachés à cet événement dans le journal de la console.

Si le code est exécuté correctement, la valeur de 2 sera affichée dans le journal de la console.

L'événement newListener

Chaque fois qu'un nouveau gestionnaire d'événements est enregistré, l'émetteur d'événements émet un événement newListener. Cet événement est utilisé pour détecter de nouveaux gestionnaires d'événements. Vous utilisez généralement l'événement newListener lorsque vous devez allouer des ressources ou effectuer une action pour chaque nouveau gestionnaire d'événements.

var events = require('events');var eventEmitter = events.EventEmitter;var emitter = new eventEmitter();emitter.on("newListener", function(eventName, listener) {console.log("Added listener for " + eventName + " events");});emitter.on('data_received', function() {});emitter.on('data_received', function() {});

Explication du code: -

Nous créons un nouveau gestionnaire d'événements pour l'événement 'newListener'. Ainsi, à chaque fois qu'un nouveau gestionnaire d'événements est enregistré, le texte "Ajout de l'écouteur pour" + le nom de l'événement sera affiché dans la console.
Ici, nous écrivons sur la console le texte "Auditeur ajouté pour" + le nom de l'événement pour chaque événement enregistré.
Nous définissons 2 gestionnaires d'événements pour notre événement 'data_received'.

Si le code ci-dessus est exécuté correctement, le texte ci-dessous sera affiché dans la console. Cela montre simplement que le gestionnaire d'événements 'newListener' a été déclenché deux fois.

Écouteur ajouté pour les événements data_received

Résumé

Les flux sont utilisés dans Node.js pour lire et écrire des données à partir de périphériques d'entrée-sortie. Node.js utilise la bibliothèque 'fs' pour créer des flux lisibles et inscriptibles dans des fichiers. Ces flux peuvent être utilisés pour lire et écrire des données à partir de fichiers.
Les tuyaux peuvent être utilisés pour connecter plusieurs flux ensemble. L'un des exemples les plus courants consiste à canaliser le flux de lecture et d'écriture ensemble pour le transfert de données d'un fichier à l'autre.
Node.js est souvent également étiqueté comme un framework piloté par les événements, et il est très facile de définir des événements dans Node.js. Des fonctions peuvent être définies pour répondre à ces événements.
Les événements exposent également des méthodes pour répondre aux événements clés. Par exemple, nous avons vu le gestionnaire d'événement once () qui peut être utilisé pour s'assurer qu'une fonction de rappel n'est exécutée qu'une seule fois lorsqu'un événement est déclenché.