Une brève analyse de l'utilisation de l'API Stream dans 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 facile à 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. Utile.

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 basée sur les événements

Vous pouvez connecter des flux via un tuyau

Types

Flux lisible Flux de données lisible

Flux de données inscriptible Stream Stream

Flux de données bidirectionnel Duplex Stream, peut lire et écrire en même temps

Flux de données de conversion Transform Stream, peut lire et écrire, peut convertir (traiter) données en même temps

Événements

Événements de flux de données lisibles

lisibles sont déclenchés lorsque les données sortent

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

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

close est déclenchée lorsque la source de données est fermée

erreur. est déclenché 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, la

finish. l'appel sera déclenché lorsqu'il pourra être réécrit. méthode de fin, il est déclenché une fois que toutes les données mises en cache sont libérées, similaire à l'événement de fin dans le flux de données lisible, indiquant la fin du processus d'écriture

le tuyau est déclenché. lorsqu'il est utilisé comme cible du canal. Déclenché lorsqu'une

erreur se produit. Déclenché lorsqu'une erreur se produit lors de l'écriture des données.

État

Il existe deux états de flux de données lisibles. : état dynamique du flux et état de pause. Méthodes pour modifier l'état du flux de données Comme suit :

État de pause-> Dynamique du flux

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

Appelez la méthode de reprise

Appelez la méthode pipe

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

Dynamique de streaming-> État de pause

Lorsqu'il n'y a pas de destination pour la méthode pipe, appelez la méthode pause

Lorsqu'il y a une destination pour la méthode pipe, supprimez fonction d'écoute de tous les événements de données et appelez la méthode unpipe pour supprimer les destinations de toutes les méthodes pipe

Remarque : seule la suppression de la fonction d'écoute de l'événement de données ne fera pas automatiquement entrer le flux de données dans « 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

Lecture et écriture de fichiers

Pour plus d'utilisation

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!');
 }));

veuillez 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 avec le contenu de rs

Le flux terminé/fermé ne peut pas être réutilisé et le flux de données doit être recréé

La méthode pipe renvoie le flux de données cible, comme a.pipe(b) renvoie b, donc l'auditeur Lors de la gestion 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

Bibliothèques de classes couramment utilisé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');
});

event-stream ressemble à de la programmation fonctionnelle, je préfère personnellement

awesome-nodejs#streams parce que. d'autres bibliothèques de flux. Aucune d'entre elles n'a été utilisée, donc si vous en avez besoin, lisez simplement ici

Le contenu ci-dessus est l'introduction de l'éditeur à l'utilisation de l'API Stream dans Node.js. .

Pour plus d'articles sur l'utilisation de l'API Stream dans Node.js, veuillez faire attention au site Web PHP chinois !