Node.js est naturellement asynchrone et axé sur l'événement, et est idéal pour gérer les tâches liées aux I / O. Si vous traitez avec des opérations liées aux I / O dans votre application, vous pouvez profiter des flux dans Node.js. Par conséquent, jetons un coup d'œil aux flux en détail et comprenons comment ils simplifient les opérations d'E / S.
Qu'est-ce que le flux
Les flux sont des pipelines UNIX qui vous permettent de lire facilement les données à partir d'une source de données, puis de passer à une autre destination.
En termes simples, le streaming n'est pas quelque chose de spécial, c'est juste un éventail qui met en œuvre certaines méthodes. Selon la méthode qu'il met en œuvre, le flux peut devenir un flux lisible (lisible), un flux écrivative (écrivable) ou un flux bidirectionnel (duplex, lisible et écrivable).
Un flux lisible vous permet de lire les données à partir d'une source de données, tandis qu'un flux inscriptible vous permet d'écrire des données sur votre destination.
Si vous avez utilisé Node.js, vous avez probablement rencontré du streaming.
Par exemple, dans un serveur HTTP Node.js, la demande est un flux lisible et la réponse est un flux écrivative.
Vous avez peut-être également utilisé le module FS, qui peut vous aider à gérer des flux lisibles et écrivatifs.
Maintenant, laissez-vous apprendre des bases et comprendre différents types de flux. Cet article discutera des flux lisibles et écrivains. Les flux bidirectionnels dépassent le champ d'application de cet article et nous n'en discuterons pas.
Streams lisibles
Nous pouvons utiliser un flux lisible pour lire les données d'une source de données, qui peut être n'importe quoi, comme un fichier dans le système, un tampon en mémoire ou même d'autres flux. Étant donné que les flux sont des éléments eventsemitters, ils envoient des données avec divers événements. Nous utiliserons ces événements pour faire fonctionner le flux.
Lire les données de Stream
La meilleure façon de lire les données d'un flux est d'écouter les événements de données et d'ajouter une fonction de rappel. Lorsque les données circulent, le flux lisible enverra un événement de données et la fonction de rappel sera déclenchée. Jetez un œil à l'extrait de code suivant:
var fs = require ('fs'); var liselleStream = fs.creareAdStream ('file.txt'); var data = ''; var liablestream.on ('data', function (chunk) {data + = chunk;}); readablestream.on ('end', function () {console.log (data);});FS.CreareAdstream vous donnera un flux lisible.
Au début, ce flux n'était pas dynamique d'écoulement. Lorsque vous ajoutez l'écouteur d'événements de Data et ajoutez une fonction de rappel, elle deviendra fluide. Après cela, il lira un petit morceau de données et le transmettra dans votre fonction de rappel.
L'implémentateur du flux détermine la fréquence de déclenchement de l'événement de données. Par exemple, la demande HTTP déclenchera l'événement de données lorsque plusieurs KBS de données seront lues. Lorsque vous lisez les données d'un fichier, vous pouvez décider de déclencher l'événement de données lorsque une ligne est terminée.
Lorsqu'il n'y a pas de données à lire (lorsqu'elle est lue à la fin du fichier), le flux enverra un événement final. Dans l'exemple ci-dessus, nous avons écouté cet événement et imprimé les données lorsque nous avons fini de lire le fichier.
Il existe une autre façon de lire les flux. Il vous suffit de continuer à appeler la méthode read () dans l'instance de flux avant de lire jusqu'à la fin du fichier.
var fs = required ('fs'); var likesestream = fs.creareAdStream ('file.txt'); var data = ''; var chunk; liabelstream.on ('lisible', function () {while ((chunk = liabelestream.read ())! = null) {data + = chunk;}}); Reaglestream.on. console.log (data);});La méthode read () lit les données du tampon interne et renvoie NULL lorsqu'il n'y a pas de données à lire.
Par conséquent, dans la boucle while, nous vérifions si read () renvoie null, et lorsqu'il renvoie nul, la boucle sera terminée.
Il convient de noter que lorsque nous pouvons lire les données du flux, l'événement lisible sera licencié.
Définir l'encodage
Par défaut, ce que vous lisez du flux est un objet tampon. Si vous lisez une chaîne, ce n'est pas pour vous. Par conséquent, vous pouvez définir le codage du flux en appelant lisible.SetEncoding () comme dans l'exemple suivant:
var fs = require ('fs'); var liselleStream = fs.creareAdStream ('file.txt'); var data = ''; likeableStream.SetEtencoding ('utf8'); likeablestream.on ('data', fonction (chunk) {data + = chunk;}); liablestream.on ('end', fonction () {console.log (});});Dans l'exemple ci-dessus, si nous définissons le codage du flux sur UTF8, les données seront analysées en UTF8 et le morceau de la fonction de rappel sera une chaîne.
Tuyauterie
Les pipelines sont un excellent mécanisme où vous pouvez lire les données d'une source de données sans gérer vous-même l'état du flux et l'écrire sur votre destination. Jetons un coup d'œil à l'exemple suivant:
var fs = require ('fs'); var liselleStream = fs.creareAdStream ('file1.txt'); var writeableStream = fs.createwRiteStream ('file2.txt'); likeablestream.pipe (writeableStream);L'exemple ci-dessus utilise la méthode tuyau () pour écrire le contenu de File1 sur fichier2. Parce que Pipe () vous aidera à gérer le flux de données, vous n'avez pas à vous soucier de la vitesse du flux de données. Cela rend la pipe () très simple et facile à utiliser.
Il convient de noter que Pipe () renvoie le flux de destination, vous pouvez donc facilement lier plusieurs flux!
Lien (chaînage)
Supposons qu'il y ait un fichier d'archives et que vous souhaitez le décompresser. Il existe de nombreuses façons d'accomplir cette tâche. Mais le moyen le plus simple est d'utiliser des pipelines et des liens:
var fs = require ('fs'); var zlib = require ('zlib'); fs.creareAdStream ('input.txt.gz') .pipe (zlib.creategunzip ()) .pipe (fs.createwRitestream ('output.txt'));Tout d'abord, nous créons un flux lisible via input.txt.gz, puis le laissons diffuser le flux zlib.creategunzip (), qui décompresse le contenu. Enfin, nous ajoutons un flux écrivative pour écrire le contenu décompressé dans un autre fichier.
Autres méthodes
Nous avons discuté de certains concepts importants dans des flux lisibles, et voici quelques façons de savoir:
1. redable.pause () Cette méthode suscitera le flux de l'écoulement. En d'autres termes, il ne déclenchera plus l'événement de données.
2. Redable.Resume () La méthode est l'opposé de ce qui précède et permettra au flux de pause de reprendre le flux.
3. Redable.Unpipe () La méthode supprimera la destination. S'il y a des paramètres passés, il permettra au flux lisible d'arrêter la destination spécifique de Liu Xiang, sinon il supprimera toutes les destinations.
Streams en écriture
Un flux écrit vous permet d'écrire des données sur votre destination. Tout comme les flux lisibles, ce sont des eventsemitters, et ils déclenchent également différents événements. Jetons un coup d'œil aux événements et méthodes qui seront déclenchés dans le flux de scénario.
Écrire pour diffuser
Pour écrire des données en tant que flux écrivative, vous devez appeler la méthode écrite () dans l'instance de flux écrit et voir l'exemple suivant:
var fs = require ('fs'); var liselleStream = fs.creareAdStream ('file1.txt'); var writeableStream = fs.createwRiteStream ('file2.txt'); likeableStream.setencoding ('utf8'); likeablestream.on ('data', function (chunk) {witheablestream.write ('chunk');Le code ci-dessus est très simple, il lit simplement les données du flux d'entrée et l'écrit à la destination avec write ().
Cette méthode renvoie une valeur booléenne pour indiquer si l'écriture est réussie. Si le retour renvoyé, cela signifie que l'écriture est réussie et que vous pouvez continuer à écrire plus de données. Si c'est faux, cela signifie que quelque chose d'erreur s'est produit et que vous ne pouvez pas continuer à écrire maintenant. Un flux écrit déclenche un événement de drainage pour vous dire que vous pouvez continuer à écrire des données.
Après avoir écrit les données
Lorsque vous n'avez pas besoin d'écrire de données, vous pouvez appeler la méthode End () pour dire au flux que vous avez terminé l'écriture. En supposant que RES est un objet de réponse HTTP, vous enverrez généralement une réponse au navigateur:
res.write («quelques données !!»);
res.end ();
Lorsque fin () est appelé, toutes les données sont écrites et le flux déclenchera ensuite un événement final. Notez qu'après avoir appelé end (), vous ne pouvez plus écrire de données dans le flux inscriptible. Par exemple, le code suivant rapportera une erreur:
res.write («quelques données !!»);
res.end ();
res.write («essayant d'écrire à nouveau»); //Erreur !
Voici quelques événements importants liés aux flux en écriture:
1.Error se déclenche lorsqu'une erreur se produit par écrit ou liant
2.Pipe Lorsque le flux lisible est lié au flux de scénario, cet événement déclenchera
3. Unpipe se déclenchera lorsque Unpepe sera appelé par un flux lisible
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.