Nodejs Stream Data Stream Manual Pengguna_node.js

1. Pengenalan

Artikel ini memperkenalkan kaedah asas untuk membangunkan atur cara menggunakan strim 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>

Pendedahan terawal kepada Strim adalah dari zaman permulaan Unix selama beberapa dekad telah membuktikan bahawa idea Strim boleh membangunkan beberapa sistem yang besar dengan mudah. Dalam unix, Stream dilaksanakan melalui |; dalam nod, sebagai modul strim terbina dalam, banyak modul teras dan modul pihak ketiga digunakan. Seperti Unix, operasi utama Stream nod juga adalah .pipe(). Pengguna boleh menggunakan mekanisme anti-tekanan untuk mengawal keseimbangan membaca dan menulis.

Strim boleh menyediakan pembangun antara muka bersatu yang boleh digunakan semula dan mengawal keseimbangan baca dan tulis antara strim melalui antara muka Strim abstrak.

2. Mengapa menggunakan Strim

I/O dalam nod adalah tak segerak, jadi membaca dan menulis ke cakera dan rangkaian memerlukan fungsi panggil balik untuk membaca data Berikut ialah kod mudah untuk pelayan muat turun fail:

<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>

Kod ini boleh mencapai fungsi yang diperlukan, tetapi perkhidmatan perlu menyimpan keseluruhan data fail ke dalam memori sebelum menghantar data fail Jika fail "data.txt" adalah besar dan jumlah konkurensi adalah besar, banyak ingatan akan terbuang. Oleh kerana pengguna perlu menunggu sehingga keseluruhan fail dicache dalam ingatan sebelum menerima data fail, ini mengakibatkan pengalaman pengguna yang agak lemah. Tetapi mujurlah, kedua-dua parameter (req, res) ialah Strim, jadi kita boleh menggunakan fs.createReadStream() dan bukannya 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>

Kaedah

.pipe() mendengar peristiwa 'data' dan 'end' fs.createReadStream(), supaya fail "data.txt" tidak perlu menyimpan cache keseluruhan fail dan blok data boleh dihantar serta-merta selepas sambungan pelanggan selesai kepada pelanggan. Manfaat lain menggunakan .pipe() ialah ia boleh menyelesaikan masalah ketidakseimbangan baca-tulis yang disebabkan apabila kelewatan pelanggan adalah sangat besar. Jika anda ingin memampatkan fail sebelum menghantarnya, anda boleh menggunakan modul pihak ketiga:

<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>

Dengan cara ini fail akan dimampatkan oleh penyemak imbas yang menyokong gzip dan mengempis. Modul penindas mengendalikan semua pengekodan kandungan.

Strim memudahkan pembangunan program.

3. Konsep asas

Terdapat lima Strim asas: boleh dibaca, boleh ditulis, diubah, dupleks dan "klasik".

3-1, paip

Semua jenis koleksi Strim menggunakan .pipe() untuk mencipta pasangan input-output, menerima src strim boleh dibaca dan mengeluarkan datanya kepada strim boleh tulis dst, seperti berikut:

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

Kaedah

.pipe(dst) mengembalikan strim dst, supaya berbilang .pipe() boleh digunakan secara berturut-turut, seperti berikut:

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

Berfungsi sama seperti kod berikut:

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

3-2, strim boleh dibaca

Dengan memanggil kaedah .pipe() strim Boleh Dibaca, data strim Boleh Dibaca boleh ditulis kepada strim Boleh Ditulis, Transformasi atau Dupleks.

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

1>Buat strim boleh dibaca

Di sini kami mencipta strim yang boleh dibaca!

<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 ) memberitahu penerima data bahawa data telah dihantar.

Perhatikan bahawa kami tidak memanggil rs.pipe(process.stdout); sebelum menolak semua kandungan data ke dalam strim boleh dibaca, tetapi semua kandungan data yang kami tolak masih dikeluarkan sepenuhnya Ini kerana strim boleh dibaca Semua ditolak data akan dicache sehingga penerima membaca data. Tetapi dalam banyak kes, adalah lebih baik untuk menolak data ke strim boleh dibaca hanya apabila data diterima, daripada menyimpan keseluruhan data. Mari tulis semula fungsi ._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>

Kod di atas dicapai dengan mengatasi kaedah _read() untuk menolak data ke dalam strim boleh dibaca hanya apabila penerima data meminta data. Kaedah _read() juga boleh menerima parameter saiz yang menunjukkan saiz data yang diminta oleh permintaan data, tetapi strim boleh dibaca boleh mengabaikan parameter ini seperti yang diperlukan.

Perhatikan bahawa kami juga boleh mewarisi strim boleh dibaca menggunakan util.inherits(). Untuk menggambarkan bahawa kaedah _read() hanya dipanggil apabila penerima data meminta data, kami membuat kelewatan apabila menolak data ke dalam strim boleh dibaca, seperti berikut:

<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>

Jalankan atur cara menggunakan arahan berikut dan kami dapati kaedah _read() hanya dipanggil 5 kali:

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

Sebab menggunakan pemasa ialah sistem memerlukan masa untuk menghantar isyarat untuk memberitahu program untuk menutup paip. Process.stdout.on('error', fn) digunakan untuk mengendalikan sistem menghantar isyarat SIGPIPE kerana arahan pengepala menutup paip, kerana ini akan menyebabkan process.stdout mencetuskan acara EPIPE. Jika anda ingin mencipta strim boleh dibaca yang boleh menolak data dalam sebarang bentuk, cuma tetapkan parameter objectMode kepada benar apabila mencipta strim, contohnya: Readable({ objectMode: true }).

2>Baca data strim boleh dibaca

Dalam kebanyakan kes, kami hanya menggunakan kaedah paip untuk mengubah hala data daripada strim boleh dibaca kepada bentuk strim yang lain, tetapi dalam beberapa kes mungkin lebih berguna untuk membaca data terus daripada strim boleh dibaca. Seperti berikut:

<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 数据流使用手册，希望对大家有所帮助！