Une brève analyse de l'utilisation de l'API Stream dans Node.js_node.js

Cet article vous présente l'API de flux node.js du moins profond au plus profond. Veuillez voir ci-dessous pour des détails spécifiques.

Introduction de base

Dans Node.js, il existe deux façons de lire des fichiers, l'une consiste à utiliser fs.readFile, l'autre consiste à utiliser fs.createReadStream pour lire.

fs.readFile est le plus familier à tous les utilisateurs de Node.js. Il est simple à comprendre et à utiliser. Mais son inconvénient est que toutes les données seront d'abord lues dans la mémoire. Lorsqu'un fichier volumineux est rencontré, l'efficacité de cette lecture est très faible.

Et fs.createReadStream lit les données via Stream. Il divise le fichier (données) en petits morceaux puis déclenche certains événements spécifiques. Nous pouvons écouter ces événements et écrire des fonctions de traitement spécifiques. Cette méthode n’est pas simple à utiliser par rapport à la précédente, mais elle est très efficace.

En fait, Stream n'est pas seulement utilisé pour le traitement de fichiers dans Node.js, il peut également être vu à d'autres endroits, tels que process.stdin/stdout, http, sockets TCP, zlib, crypto, etc.

Cet article est un résumé de mon apprentissage sur l'API Stream dans Node.js. J'espère qu'il sera utile à tout le monde.

Caractéristiques

Communication événementielle

Vous pouvez connecter des flux via un tuyau

Tapez

Flux de données lisible Readable Stream

Flux de données inscriptible Streamable

Duplex Stream est un flux de données bidirectionnel qui peut lire et écrire en même temps

Transform Stream convertit les flux de données, qui peuvent être lus et écrits, et peut également convertir (traiter) des données

Événement

Événements pour flux de données lisibles

déclencheurs lisibles lorsque les données sortent

données Pour les flux de données qui ne sont pas explicitement mis en pause, ajoutez la fonction d'écoute des événements de données, qui fera basculer le flux de données vers la dynamique du flux et fournira des données à l'extérieur dès que possible

end est déclenché lorsque les données sont lues. Notez qu'il ne peut pas être confondu avec writeableStream.end() n'a pas d'événement de fin, seulement la méthode .end()

.

déclencheurs de fermeture lorsque la source de données est fermée

erreur déclenchée lorsqu'une erreur se produit lors de la lecture des données

Événements de flux de données inscriptibles

drain writable.write(chunk) renvoie false Une fois que tout le cache est écrit, il sera déclenché lorsqu'il pourra être à nouveau écrit

Lorsque finish appelle la méthode .end, elle est déclenchée une fois que toutes les données mises en cache sont libérées, similaire à l'événement end dans le flux de données lisible, indiquant la fin du processus d'écriture

Déclenché lorsque le tuyau est utilisé comme cible du tuyau

unpipe Déclenché lorsque unpipe est la cible

erreur déclenchée lorsqu'une erreur se produit lors de l'écriture de données

Statut

Le flux de données lisible a deux états : l'état dynamique du flux et l'état de pause. La méthode pour modifier l'état du flux de données est la suivante :

Statut de pause -> Statut de diffusion

Ajouter une fonction d'écoute pour l'événement de données

Méthode de reprise d'appel

Appelez la méthode pipe

Remarque : s'il n'y a pas de fonction d'écoute pour l'événement de données ni de destination pour la méthode pipe lors de la conversion en dynamique de streaming, les données seront perdues.

Statut du streaming -> Statut de pause

Lorsque la destination de la méthode pipe n'existe pas, la méthode pause est appelée

Lorsqu'il existe une destination pour la méthode pipe, supprimez toutes les fonctions d'écoute des événements de données et appelez la méthode unpipe pour supprimer toutes les destinations de la méthode pipe

Remarque : seule la suppression de la fonction d'écoute de l'événement de données ne fera pas automatiquement passer le flux de données à « l'état de pause ». De plus, l'appel de la méthode pause lorsqu'il existe des destinations de la méthode pipe ne garantit pas que le flux de données est toujours mis en pause une fois que ces destinations émettent des demandes de données, le flux de données peut continuer à fournir des données.

Utilisation

Lire et écrire des fichiers

var fs = require('fs');
// 新建可读数据流
var rs = fs.createReadStream('./test1.txt');
// 新建可写数据流
var ws = fs.createWriteStream('./test2.txt');
// 监听可读数据流结束事件
rs.on('end', function() {
 console.log('read text1.txt successfully!');
});
// 监听可写数据流结束事件
ws.on('finish', function() {
 console.log('write text2.txt successfully!');
});
// 把可读数据流转换成流动态，流进可写数据流中
rs.pipe(ws);
读取 CSV 文件，并上传数据（我在生产环境中写过）
var fs = require('fs');
var es = require('event-stream');
var csv = require('csv');
var parser = csv.parse();
var transformer = csv.transform(function(record) {
 return record.join(',');
});
var data = fs.createReadStream('./demo.csv');
data
 .pipe(parser)
 .pipe(transformer)
 // 处理前一个 stream 传递过来的数据
 .pipe(es.map(function(data, callback) {
  upload(data, function(err) {
   callback(err);
  });
 }))
 // 相当于监听前一个 stream 的 end 事件
 .pipe(es.wait(function(err, body) {
  process.stdout.write('done!');
 }));

Plus d'utilisation

Vous pouvez vous référer à https://github.com/jeresig/node-stream-playground Après avoir accédé à l'exemple de site Web, cliquez directement sur Ajouter un flux pour voir les résultats.

Pièges courants

L'utilisation de rs.pipe(ws) pour écrire des fichiers n'ajoute pas le contenu de rs à l'arrière de ws, mais écrase directement le contenu original de ws par le contenu de rs

Les flux terminés/fermés ne peuvent pas être réutilisés et le flux de données doit être recréé

La méthode pipe renvoie le flux de données cible, par exemple, a.pipe(b) renvoie b, donc lorsque vous écoutez des événements, veuillez faire attention à savoir si l'objet que vous surveillez est correct

Si vous souhaitez surveiller plusieurs flux de données et que vous utilisez la méthode pipe pour connecter les flux de données en série, vous devez écrire :

données

.on('end', function() {
 console.log('data end');
})
.pipe(a)
.on('end', function() {
 console.log('a end');
})
.pipe(b)
.on('end', function() {
 console.log('b end');
});

Bibliothèques de classes couramment utilisées

Event-stream ressemble à une programmation fonctionnelle lorsqu'il est utilisé, ce que j'aime personnellement

awesome-nodejs#streams Puisque je n'ai jamais utilisé d'autres bibliothèques de flux, donc si vous en avez besoin, regardez ici

Le contenu ci-dessus est l'utilisation de l'API Stream dans Node.js introduite par l'éditeur. J'espère qu'il vous plaira.