Explication détaillée des opérations de lecture et d'écriture du fichier Node.js Streams

Node.js est intrinsèquement asynchrone et piloté par les événements, ce qui le rend idéal pour gérer les tâches liées aux E/S. Si vous gérez des opérations liées aux E/S dans votre application, vous pouvez profiter des flux dans Node.js. Examinons donc les flux en détail et comprenons comment ils simplifient les opérations d'E/S.

Qu'est-ce qu'un flux ?
Un flux est un canal Unix qui vous permet de lire facilement les données d'une source de données, puis de les diffuser vers une autre destination.
Pour faire simple, un stream n'a rien de spécial, c'est juste un EventEmitter qui implémente certaines méthodes. Selon la façon dont il est implémenté, un flux peut devenir un flux lisible (Readable), un flux inscriptible (Writable), ou un flux bidirectionnel (Duplex, simultanément lisible et inscriptible).
Les flux lisibles vous permettent de lire des données à partir d'une source de données, tandis que les flux inscriptibles vous permettent d'écrire des données vers une destination.
Si vous avez utilisé Node.js, vous avez probablement rencontré des flux.
Par exemple, dans un serveur HTTP Node.js, la requête est un flux lisible et la réponse est un flux inscriptible.
Vous avez peut-être également utilisé le module fs, qui peut vous aider à gérer les flux lisibles et inscriptibles.
Apprenons maintenant quelques bases et comprenons les différents types de flux. Cet article traitera des flux lisibles et des flux inscriptibles. Les flux bidirectionnels dépassent la portée de cet article et nous n'en discuterons pas.
Flux lisibles
Nous pouvons utiliser des flux lisibles pour lire des données à partir d'une source de données. Cette source de données 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 EventEmitters, ils envoient des données avec divers événements. Nous utiliserons ces événements pour faire fonctionner le flux.

Lire les données du flux
La meilleure façon de lire les données du flux est d'écouter l'événement de données et d'ajouter une fonction de rappel. Lorsque les données entrent, le flux lisible enverra l'é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 readableStream = fs.createReadStream('file.txt');
var data = '';
 
var readableStream.on('data', function(chunk){
 data += chunk;
});
 
readableStream.on('end', function(){
 console.log(data);
});

fs.createReadStream vous donnera un flux lisible.
Au début, ce flux n'est pas dynamique. Lorsque vous ajoutez un écouteur d'événement pour les données et ajoutez une fonction de rappel, cela deviendra fluide. Après cela, il lira un petit morceau de données et le transmettra à votre fonction de rappel.
L'implémenteur du flux détermine la fréquence à laquelle l'événement de données est déclenché. Par exemple, une requête HTTP déclenchera l'événement de données lorsque quelques Ko de données sont lus. Lorsque vous lisez des données à partir d'un fichier, vous pouvez décider de déclencher l'événement data lors de la lecture d'une ligne.
Lorsqu'il n'y a aucune donnée à lire (lorsque la fin du fichier est lue), le flux enverra l'événement de fin. 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 un flux. Il vous suffit de continuer à appeler la méthode read() sur l'instance du flux avant de lire la fin du fichier. La méthode

var fs = require('fs');
var readableStream = fs.createReadStream('file.txt');
var data = '';
var chunk;
 
readableStream.on('readable', function(){
 while ((chunk = readableStream.read()) != null) {
 data += chunk;
 }
});
 
readableStream.on('end', function(){
 console.log(data);
});

read() lira les données du tampon interne Lorsqu'il n'y a aucune donnée à lire, elle renverra null .
Ainsi, dans la boucle while, nous vérifions si read() renvoie null, et lorsqu'il renvoie null, nous terminons la boucle.
Il convient de noter que lorsque nous pourrons lire les données du flux, l'événement lisible sera déclenché.
Définir l'encodage
Par défaut, ce que vous lisez dans le flux est un objet Buffer. Si vous souhaitez lire des chaînes, cela ne vous convient pas. Par conséquent, vous pouvez définir l'encodage du flux en appelant Readable.setEncoding() comme dans l'exemple suivant :

var fs = require('fs');
var readableStream = fs.createReadStream('file.txt');
var data = '';
 
readableStream.setEncoding('utf8');
 
readableStream.on('data', function(chunk){
 data += chunk;
});
 
readableStream.on('end', function(){
 console.log(data);
});

Dans l'exemple ci-dessus, nous définissons l'encodage du flux sur utf8, et les données sera analysé en utf8, le morceau de la fonction de rappel sera une chaîne.
Piping
Le piping est un excellent mécanisme qui vous permet de lire des données à partir d'une source de données et de les écrire vers la destination sans avoir à gérer vous-même l'état du flux. Jetons d'abord un coup d'œil à l'exemple suivant :

var fs = require('fs');
var readableStream = fs.createReadStream('file1.txt');
var writableStream = fs.createWriteStream('file2.txt');
 
readableStream.pipe(writableStream);

L'exemple ci-dessus utilise la méthode pipe() pour écrire le contenu du fichier1 dans le fichier2. Étant donné que pipe() gérera le flux de données pour vous, vous n'avez pas à vous soucier de la vitesse du flux de données. Cela rend pipe() très concis et facile à utiliser.
Il convient de noter que pipe() renverra le flux de destination, vous pourrez donc facilement lier plusieurs flux !
Chaînage
Supposons que vous ayez une archive et que vous souhaitiez la décompresser. Il existe de nombreuses façons d'accomplir cette tâche. Mais le moyen le plus simple est d'utiliser des tubes et des liens :

var fs = require('fs');
var zlib = require('zlib');
 
fs.createReadStream('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 nous le laissons couler le flux zlib.createGunzip(), qui le décompressera. contenu. Enfin, nous ajoutons un flux inscriptible pour écrire le contenu décompressé dans un autre fichier.
Autres méthodes
Nous avons discuté de quelques concepts importants dans les flux lisibles, voici quelques méthodes que vous devez connaître :
1.Readable.pause() – Cette méthode mettra en pause le flux du flux. En d’autres termes, cela ne déclenchera plus l’événement data.
2.Readable.resume() – Cette méthode est à l’opposé de celle ci-dessus et reprendra le flux en pause.
3.Readable.unpipe() – Cette méthode supprimera la destination. Si des paramètres sont transmis, cela arrêtera le flux lisible à partir d’une destination spécifique, sinon il supprimera toutes les destinations.

可写流 (Writable Streams)
可写流让你把数据写入目的地。就像可读流那样，这些也是 EventEmitter ，它们也会触发不同的事件。我们来看看可写流中会触发的事件和方法吧。
写入流
要把数据写如到可写流中，你需要在可写流实例中调用 write() 方法，看看下面的例子：

var fs = require('fs');
var readableStream = fs.createReadStream('file1.txt');
var writableStream = fs.createWriteStream('file2.txt');
 
readableStream.setEncoding('utf8');
 
readableStream.on('data', function(chunk){
 writableStream.write('chunk');
});

上面的代码非常简单，它只是从输入流中读取数据，然后用 write() 写入到目的地中。
 这个方法返回一个布尔值来表示写入是否成功。如果返回的是 true 那表示写入成功，你可以继续写入更多的数据。 如果是 false ，那意味着发生了什么错误，你现在不能继续写入了。可写流会触发一个 drain 事件来告诉你你可以继续写入数据。
 写完数据后
 当你不需要在写入数据的时候，你可以调用 end() 方法来告诉流你已经完成写入了。假设 res 是一个 HTTP response 对象，你通常会发送响应给浏览器：
res.write('Some Data!!');
res.end();
当 end() 被调用时，所有数据会被写入，然后流会触发一个 finish 事件。注意在调用 end() 之后，你就不能再往可写流中写入数据了。例如下面的代码就会报错：
res.write('Some Data!!');
res.end();
res.write('Trying to write again'); //Error !
这里有一些和可写流相关的重要事件：
 1.error – 在写入或链接发生错误时触发
 2.pipe – 当可读流链接到可写流时，这个事件会触发
 3.unpipe – 在可读流调用 unpipe 时会触发

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持PHP中文网。

更多Node.js Streams文件读写操作详解相关文章请关注PHP中文网！