Manuel d'utilisation du flux de données Nodejs Stream_node.js

1. Introduction

Cet article présente la méthode de base de développement de programmes à l'aide de flux node.js.

<code class="hljs mizar">"We should have some ways of connecting programs like garden hose--screw in
another segment when it becomes necessary to massage data in
another way. This is the way of IO also."
Doug McIlroy. October 11, 1964</code>

La première exposition à Stream remonte aux débuts d'Unix. Des décennies de pratique ont prouvé que les idées Stream peuvent facilement développer d'énormes systèmes. Sous Unix, Stream est implémenté via |; dans le nœud, en tant que module de flux intégré, de nombreux modules de base et modules tiers sont utilisés. Comme Unix, l'opération principale de node Stream est également .pipe(). Les utilisateurs peuvent utiliser le mécanisme anti-pression pour contrôler l'équilibre de la lecture et de l'écriture.

Stream peut fournir aux développeurs une interface unifiée qui peut être réutilisée et contrôler l'équilibre de lecture et d'écriture entre les flux via l'interface abstraite Stream.

2. Pourquoi utiliser Stream

Les E/S dans le nœud sont asynchrones, donc la lecture et l'écriture sur le disque et le réseau nécessitent des fonctions de rappel pour lire les données. Ce qui suit est un code simple pour un serveur de téléchargement de fichiers :

.

<code class="hljs javascript">var http = require('http');
var fs = require('fs');
var server = http.createServer(function (req, res) {
fs.readFile(__dirname + '/data.txt', function (err, data) {
res.end(data);
});
});
server.listen(8000);</code>

Ces codes peuvent réaliser les fonctions requises, mais le service doit mettre en cache toutes les données du fichier en mémoire avant d'envoyer les données du fichier. Si le fichier "data.txt" est volumineux et que la quantité de concurrence est importante, beaucoup de données. la mémoire sera gaspillée. Étant donné que l'utilisateur doit attendre que l'intégralité du fichier soit mise en cache en mémoire avant d'accepter les données du fichier, cela entraîne une très mauvaise expérience utilisateur. Mais heureusement, les deux paramètres (req, res) sont Stream, nous pouvons donc utiliser fs.createReadStream() au lieu de fs.readFile() :

<code class="hljs javascript">var http = require('http');
var fs = require('fs');
var server = http.createServer(function (req, res) {
var stream = fs.createReadStream(__dirname + '/data.txt');
stream.pipe(res);
});
server.listen(8000);</code>

La méthode

.pipe() écoute les événements 'data' et 'end' de fs.createReadStream(), de sorte que le fichier "data.txt" n'ait pas besoin de mettre en cache l'intégralité du fichier et qu'un bloc de données puisse être envoyé immédiatement après la connexion du client au client. Un autre avantage de l'utilisation de .pipe() est qu'il peut résoudre le problème de déséquilibre lecture-écriture provoqué lorsque le délai client est très important. Si vous souhaitez compresser le fichier avant de l'envoyer, vous pouvez utiliser un module tiers :

<code class="hljs javascript">var http = require('http');
var fs = require('fs');
var oppressor = require('oppressor');
var server = http.createServer(function (req, res) {
var stream = fs.createReadStream(__dirname + '/data.txt');
stream.pipe(oppressor(req)).pipe(res);
});
server.listen(8000);</code>

De cette façon, le fichier sera compressé pour les navigateurs prenant en charge gzip et deflate. Le module oppresseur gère tout l’encodage du contenu.

Stream facilite le développement de programmes.

3.Concepts de base

Il existe cinq flux de base : lisible, inscriptible, transformé, duplex et "classique".

3-1, pipe

Tous les types de collection Stream utilisent .pipe() pour créer une paire entrée-sortie, recevoir un flux src lisible et afficher ses données vers un flux dst inscriptible, comme suit :

<code class="hljs perl">src.pipe(dst)</code>

La méthode

.pipe(dst) renvoie le flux dst, afin que plusieurs .pipe() puissent être utilisés successivement, comme suit :

<code class="hljs perl">a.pipe( b ).pipe( c ).pipe( d )</code>

Fonctionne de la même manière que le code suivant :

<code class="hljs perl">a.pipe( b );
b.pipe( c );
c.pipe( d );</code>

3-2, flux lisibles

En appelant la méthode .pipe() des flux Readable, les données des flux Readable peuvent être écrites dans un flux Writable, Transform ou Duplex.

<code class="hljs perl">readableStream.pipe( dst )</code>

1>Créer un flux lisible

Ici, nous créons un flux lisible !

<code class="hljs perl">var Readable = require('stream').Readable;
var rs = new Readable;
rs.push('beep ');
rs.push('boop\n');
rs.push(null);
rs.pipe(process.stdout);
$ node read0.js
beep boop
</code>

rs.push( null ) informe le destinataire des données que les données ont été envoyées.

Remarquez que nous n'avons pas appelé rs.pipe(process.stdout); avant de pousser tout le contenu des données dans le flux lisible, mais que tout le contenu des données que nous avons inséré était toujours complètement sorti. C'est parce que le flux lisible est tout poussé. les données seront mises en cache jusqu'à ce que le récepteur les lise. Mais dans de nombreux cas, il est préférable de transférer les données vers le flux lisible uniquement lorsque les données sont reçues, plutôt que de mettre en cache l'intégralité des données. Réécrivons la fonction ._read() :

<code class="hljs javascript">var Readable = require('stream').Readable;
var rs = Readable();
var c = 97;
rs._read = function () {
rs.push(String.fromCharCode(c++));
if (c > 'z'.charCodeAt(0)) rs.push(null);
};
rs.pipe(process.stdout);</code>
<code class="hljs bash">$ node read1.js
abcdefghijklmnopqrstuvwxyz</code>

Le code ci-dessus parvient à remplacer la méthode _read() pour pousser les données dans le flux lisible uniquement lorsque le destinataire des données demande des données. La méthode _read() peut également recevoir un paramètre size indiquant la taille des données demandée par la requête de données, mais le flux lisible peut ignorer ce paramètre si nécessaire.

Notez que nous pouvons également hériter de flux lisibles en utilisant util.inherits(). Afin d'illustrer que la méthode _read() n'est appelée que lorsque le récepteur de données demande des données, nous effectuons un délai lors du transfert des données dans le flux lisible, comme suit :

<code class="hljs javascript">var Readable = require('stream').Readable;
var rs = Readable();
var c = 97 - 1;
rs._read = function () {
if (c >= 'z'.charCodeAt(0)) return rs.push(null);
setTimeout(function () {
rs.push(String.fromCharCode(++c));
}, 100);
};
rs.pipe(process.stdout);
process.on('exit', function () {
console.error('\n_read() called ' + (c - 97) + ' times');
});
process.stdout.on('error', process.exit);</code>

Exécutez le programme en utilisant la commande suivante et nous constatons que la méthode _read() n'est appelée que 5 fois :

<code class="hljs bash">$ node read2.js | head -c5
abcde
_read() called 5 times</code>

La raison de l'utilisation d'une minuterie est que le système a besoin de temps pour envoyer un signal pour avertir le programme de fermer le tuyau. Process.stdout.on('error', fn) est utilisé pour gérer le système qui envoie un signal SIGPIPE car la commande d'en-tête ferme le canal, car cela entraînera le déclenchement de l'événement EPIPE par process.stdout. Si vous souhaitez créer un flux lisible capable de transmettre des données sous n'importe quelle forme, définissez simplement le paramètre objectMode sur true lors de la création du flux, par exemple : Readable({ objectMode: true }).

2>Lire les données de flux lisibles

Dans la plupart des cas, nous utilisons simplement la méthode pipe pour rediriger les données du flux lisible vers une autre forme de flux, mais dans certains cas, il peut être plus utile de lire les données directement à partir du flux lisible. Comme suit :

<code class="hljs php">process.stdin.on('readable', function () {
var buf = process.stdin.read();
console.dir(buf);
});
$ (echo abc; sleep 1; echo def; sleep 1; echo ghi) | node consume0.js 
<buffer 0a="" 61="" 62="" 63="">
<buffer 0a="" 64="" 65="" 66="">
<buffer 0a="" 67="" 68="" 69="">
null</buffer></buffer></buffer></code>

当可读流中有数据可读取时，流会触发'readable' 事件，这样就可以调用.read()方法来读取相关数据，当可读流中没有数据可读取时，.read() 会返回null，这样就可以结束.read() 的调用， 等待下一次'readable' 事件的触发。下面是一个使用.read(n)从标准输入每次读取3个字节的例子：

<code class="hljs javascript">process.stdin.on('readable', function () {
var buf = process.stdin.read(3);
console.dir(buf);
});</code>

如下运行程序发现，输出结果并不完全!

<code class="hljs bash">$ (echo abc; sleep 1; echo def; sleep 1; echo ghi) | node consume1.js 
<buffer 61="" 62="" 63="">
<buffer 0a="" 64="" 65="">
<buffer 0a="" 66="" 67=""></buffer></buffer></buffer></code>

这是应为额外的数据数据留在流的内部缓冲区里了，而我们需要通知流我们要读取更多的数据.read(0)可以达到这个目的。

<code class="hljs javascript">process.stdin.on('readable', function () {
var buf = process.stdin.read(3);
console.dir(buf);
process.stdin.read(0);
});</code>

这次运行结果如下：

<code class="hljs xml">$ (echo abc; sleep 1; echo def; sleep 1; echo ghi) | node consume2.js 
<buffer 0a="" 64="" 65="">
<buffer 0a="" 68="" 69=""></buffer></buffer></code>

我们可以使用 .unshift() 将数据重新押回流数据队列的头部，这样可以接续读取押回的数据。如下面的代码，会按行输出标准输入的内容：

<code class="hljs javascript">var offset = 0;
process.stdin.on('readable', function () {
var buf = process.stdin.read();
if (!buf) return;
for (; offset < buf.length; offset++) {
if (buf[offset] === 0x0a) {
console.dir(buf.slice(0, offset).toString());
buf = buf.slice(offset + 1);
offset = 0;
process.stdin.unshift(buf);
return;
}
}
process.stdin.unshift(buf);
});
$ tail -n +50000 /usr/share/dict/american-english | head -n10 | node lines.js 
'hearties'
'heartiest'
'heartily'
'heartiness'
'heartiness\'s'
'heartland'
'heartland\'s'
'heartlands'
'heartless'
'heartlessly'</code>

当然，有很多模块可以实现这个功能，如：split 。

3-3、writable streams

writable streams只可以作为.pipe()函数的目的参数。如下代码：

<code class="hljs perl">src.pipe( writableStream );</code>

1>创建 writable stream

重写 ._write(chunk, enc, next) 方法就可以接受一个readable stream的数据。

<code class="hljs php">var Writable = require('stream').Writable;
var ws = Writable();
ws._write = function (chunk, enc, next) {
console.dir(chunk);
next();
};
process.stdin.pipe(ws);
$ (echo beep; sleep 1; echo boop) | node write0.js 
<buffer 0a="" 62="" 65="" 70="">
<buffer 0a="" 62="" 6f="" 70=""></buffer></buffer></code>

第一个参数chunk是数据输入者写入的数据。第二个参数end是数据的编码格式。第三个参数next(err)通过回调函数通知数据写入者可以写入更多的时间。如果readable stream写入的是字符串，那么字符串会默认转换为Buffer，如果在创建流的时候设置Writable({ decodeStrings: false })参数，那么不会做转换。如果readable stream写入的数据时对象，那么需要这样创建writable stream

<code class="hljs css">Writable({ objectMode: true })</code>

2>写数据到 writable stream

调用writable stream的.write(data)方法即可完成数据写入。

<code class="hljs vala">process.stdout.write('beep boop\n');</code>

调用.end()方法通知writable stream 数据已经写入完成。

<code class="hljs javascript">var fs = require('fs');
var ws = fs.createWriteStream('message.txt');
ws.write('beep ');
setTimeout(function () {
ws.end('boop\n');
}, 1000);
$ node writing1.js 
$ cat message.txt
beep boop</code>

如果需要设置writable stream的缓冲区的大小，那么在创建流的时候，需要设置opts.highWaterMark，这样如果缓冲区里的数据超过opts.highWaterMark，.write(data)方法会返回false。当缓冲区可写的时候，writable stream会触发'drain' 事件。

3-4、classic streams

Classic streams比较老的接口了，最早出现在node 0.4版本中，但是了解一下其运行原理还是十分有好
处的。当一个流被注册了"data" 事件的回到函数，那么流就会工作在老版本模式下，即会使用老的API。

1>classic readable streams

Classic readable streams事件就是一个事件触发器，如果Classic readable streams有数据可读取，那么其触发 "data" 事件，等到数据读取完毕时，会触发"end" 事件。.pipe() 方法通过检查stream.readable 的值确定流是否有数据可读。下面是一个使用Classic readable streams打印A-J字母的例子：

<code class="hljs javascript">var Stream = require('stream');
var stream = new Stream;
stream.readable = true;
var c = 64;
var iv = setInterval(function () {
if (++c >= 75) {
clearInterval(iv);
stream.emit('end');
}
else stream.emit('data', String.fromCharCode(c));
}, 100);
stream.pipe(process.stdout);
$ node classic0.js
ABCDEFGHIJ</code>

如果要从classic readable stream中读取数据，注册"data" 和"end"两个事件的回调函数即可，代码如下：

<code class="hljs php">process.stdin.on('data', function (buf) {
console.log(buf);
});
process.stdin.on('end', function () {
console.log('__END__');
});
$ (echo beep; sleep 1; echo boop) | node classic1.js 
<buffer 0a="" 62="" 65="" 70="">
<buffer 0a="" 62="" 6f="" 70="">
__END__</buffer></buffer></code>

需要注意的是如果你使用这种方式读取数据，那么会失去使用新接口带来的好处。比如你在往一个 延迟非常大的流写数据时，需要注意读取数据和写数据的平衡问题，否则会导致大量数据缓存在内存中，导致浪费大量内存。一般这时候强烈建议使用流的.pipe()方法，这样就不用自己监听”data” 和”end”事件了，也不用担心读写不平衡的问题了。当然你也可以用 through代替自己监听”data” 和”end” 事件，如下面的代码：

<code class="hljs php">var through = require('through');
process.stdin.pipe(through(write, end));
function write (buf) {
console.log(buf);
}
function end () {
console.log('__END__');
}
$ (echo beep; sleep 1; echo boop) | node through.js 
<buffer 0a="" 62="" 65="" 70="">
<buffer 0a="" 62="" 6f="" 70="">
__END__</buffer></buffer></code>

或者也可以使用concat-stream来缓存整个流的内容：

<code class="hljs oxygene">var concat = require('concat-stream');
process.stdin.pipe(concat(function (body) {
console.log(JSON.parse(body));
}));
$ echo '{"beep":"boop"}' | node concat.js 
{ beep: 'boop' }</code>

当然如果你非要自己监听"data" 和"end"事件，那么你可以在写数据的流不可写的时候使用.pause()方法暂停Classic readable streams继续触发”data” 事件。等到写数据的流可写的时候再使用.resume() 方法通知流继续触发"data" 事件继续读取
数据。

2>classic writable streams

Classic writable streams 非常简单。只有 .write(buf), .end(buf)和.destroy()三个方法。.end(buf) 方法的buf参数是可选的，如果选择该参数，相当于stream.write(buf); stream.end() 这样的操作，需要注意的是当流的缓冲区写满即流不可写时.write(buf)方法会返回false，如果流再次可写时，流会触发drain事件。

4、transform

transform是一个对读入数据过滤然输出的流。

5、duplex

duplex stream是一个可读也可写的双向流，如下面的a就是一个duplex stream:

<code class="hljs livecodeserver">a.pipe(b).pipe(a)</code>

以上内容是小编给大家介绍的Nodejs Stream 数据流使用手册，希望对大家有所帮助！