Tutoriel Node js Streams : Filestream, Pipes
James Hartmann
Flux de fichiers dans Node.js
Node utilise largement les flux comme mécanisme de transfert de données.
Par exemple, lorsque vous envoyez quelque chose à 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 les données des fichiers afin qu'elles puissent être lues et écrites de manière appropriée. Nous allons maintenant examiner 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
Connectivité des données
Utiliser le jasmin
É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 dans lequel 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 va effectuer 2 étapes fondamentales. La première consiste à convertir les données lues dans le fichier en chaîne. La seconde serait d'envoyer la chaîne convertie en sortie à la console.
- Nous prenons chaque morceau de données lu à partir du flux de données et le convertissons en chaîne.
- Enfin, nous envoyons la sortie de chaque morceau converti de chaîne à la console.
Sortie :
- 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 inscriptible 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
Generators
Connectivité des données
En utilisant Jasmine
Tuyaux dans Node.js
Dans les applications Node, les flux peuvent être regroupés à l'aide de la méthode pipe(), qui prend deux arguments :
- Un flux inscriptible requis qui fait office de destination pour les données et
- Un objet facultatif utilisé pour transmettre des options.
Un exemple typique d'utilisation de tubes, si vous souhaitez transférer des données d'un fichier à un autre.
Voyons donc un exemple de la façon dont nous pouvons transférer des données d'un fichier à un autre à l'aide de canaux.
É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
Generators
Connectivité des données
Utiliser le jasmin
Étape 2) Créez un fichier vide vide appelé dataOutput.txt et placez-le sur le lecteur D de votre ordinateur local.
É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 du transfert de données 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 transmettra au 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é un framework piloté 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.
Examinons 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 définie à l'étape 3.
- Nous définissons une fonction basée sur les événements qui dit que si l'événement « data_received » est déclenché, nous devons afficher le texte « data_received » sur la console.
- Enfin, nous disposons d'un déclenchement 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.
Émission d'événements
Lors de la définition d'événements, différentes méthodes peuvent être invoquées pour les événements. Ce sujet se concentre sur l’examen de chacun d’eux en détail.
- Gestionnaires d'événements ponctuels
Parfois, vous souhaiterez peut-être réagir à un événement seulement 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. Cela est dû à 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 dans le journal sera « data_received with success ». Ce message n'apparaîtra qu'une seule fois dans la console.
- Inspection des écouteurs d'événements
À tout moment de sa durée de vie, un émetteur d’événements peut être associé à zéro ou plusieurs écouteurs. 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 utiliser les méthodes liées aux événements.
- Nous définissons ensuite 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 pratiquement rien. Ceci reste simple pour notre exemple juste pour montrer comment fonctionne la méthode listeningCount.
- 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 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 « Écouteur ajouté pour » + le nom de l'événement sera affiché dans la console.
- Ici, nous écrivons sur la console le texte « Écouteur 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.
Ajout d'un écouteur pour les événements data_received
Ajout d'un écouteur 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 vers 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 à regrouper les flux de lecture et d’écriture 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 permettant de répondre aux événements clés. Par exemple, nous avons vu le gestionnaire d'événements once() qui peut être utilisé pour garantir qu'une fonction de rappel n'est exécutée qu'une seule fois lorsqu'un événement est déclenché.
