8 
var fs = require('fs');

var file = fs.createReadStream('./zeros.txt');
var dataSize = 0;

file.on('readable', function () {
    var data = file.read(10);
    console.log('readable size = ', data.length);
    console.log(data.toString());
});

Thie 文件“zeros.txt”包含 700 个字符“0”

据我了解，在调用 read(10) 之后，流必须停止并等待新的 read() 调用。但是，调用的结果：

readable size =  10
0000000000
readable size =  10
0000000000
4

2 回答 2

10

在 Node.js 将文件（整个或只是一部分，取决于文件本身的大小）加载到缓冲区后（使用 push() 方法），它将发出readable event指示某些数据已被读入缓冲区并可以使用了。然后在你调用 之后read(10)，你将释放缓冲区，然后 Node.js 将再次自动填充缓冲区并再次发出readable event表示仍有一些数据要从缓冲区读取。如果您调用read(700)，则不会再次发出 next readable event。

流动和非流动模式

与侦听data event流不同，它将保持所谓的非流动模式。这意味着开发人员将负责释放流（从流中读取）。另一方面，当侦听流时data event，流将自动进入所谓的流动模式，这意味着流本身将负责释放自己，即流将自己填充和清空，直到底层系统（在这种情况下zero.txt将是完整阅读）。请注意，无论哪种模式，缓冲区都会自动填充数据。

流动模式

非流动模式的一个例子，我们必须手动清空缓冲区（使用read()方法）：

var fs = require('fs'),
util = require('util');

// I have increased the file size to 19 MB (about 19 mln characters);
// Cause of the buffer capicity.
var file = fs.createReadStream('./zeros.txt'); 
var dataSize = 0;

// Readable will be called when the buffer has been filled with data.
// Initially Node.js will fill the buffer with data automatically,
// so this event will be called automatically aswell of course.
// Once the buffer will be free again after the first fill, Node.js
// will fill the buffer automatically again. Node.js just watches this stream
// and makes sure to fill it, when there is still some unread data in the zero.txt file.
file.on('readable', function() {
var i = 0; // we will count how many times did while loop, for fun

// If the buffer will be empty Node will write data to the buffer
// automatically, we don't have to care about that. However
// you can specify the buffer capicty manually if you want.
console.log('loading more data from the underlying system');

// This will make the stream read 1000 bytes
// it will also return a value NULL if there is not enough 
// data to read from the buffer (meaning buffer has been fully read 
// or there is still some data but you are trying to read 1000 bytes 
// and there is less than 1000 bytes left)
while(file.read(1000) !== null) {
    i++;
}
// At this moment while loop has read everything from the buffer.
// The buffer is now empty. After this comment console.log will execute
// Node.js will fill the buffer again with new data automatically.
// And then the 'readable' event will fire again.
console.log("had to loop: " + i + " times before the buffer was empty");
})

控制台的最后几个结果：

loading more data from the underlying system
had to loop: 66 times before the buffer was empty
loading more data from the underlying system
had to loop: 65 times before the buffer was empty
loading more data from the underlying system
had to loop: 66 times before the buffer was empty
loading more data from the underlying system
had to loop: 46 times before the buffer was empty
loading more data from the underlying system
had to loop: 1 times before the buffer was empty

非流动模式

那是非流动模式，因为我们必须手动释放缓冲区。现在我们将进入流动模式。data event listener在 a上设置 aReadable Stream会将流flowing mode从初始non-flowing mode. 这意味着缓冲区将被自动清空。Node.js 会将数据作为参数传递给你data event listener，一旦该函数执行，缓冲区将再次清空，如果底层源缓冲区中仍有一些数据将自动填充新数据，然后数据事件将再次发出。注意：如果您正在侦听该data事件并且readable event两者都会触发，但data event listener首先会清空缓冲区，然后readable event才会触发，因此您read()将始终返回NULL。

var fs = require('fs'),
util = require('util');

var file = fs.createReadStream('./zeros.txt');
var dataSize = 0;

file.on('data', function() {
    // Once this listener will stop executing new data will be read
    // into the buffer and then the 'data' event will be emitted
    // again.
    console.log('data has been loaded and emptied!')
})

file.on('readable', function () {
    // Notice we want to try to read 1 byte from the buffer
    // but in the console we see that the read() method
    // resulted in NULL, which means that the buffer is empty.
    // That's of course because we enterd the flowing mode
    // by setting up the 'data' event. (In flowing mode)
    // after the execution of the 'data' event all data
    // from the buffer will be read, but the execution
    // of listeners will continue. After all the event listeners
    // attached to this stream will execute, Node.js will fill
    // the buffer automatically again.
    console.log('readable ' + file.read(1))
});

控制台的最后几个结果：

data has been loaded and emptied!
readable null
data has been loaded and emptied!
readable null
data has been loaded and emptied!
readable null
data has been loaded and emptied!
readable null
data has been loaded and emptied!
readable null
于 2014-03-30T23:01:50.973 回答
2

我的回答是基于 0.12.4 的版本。

1：当当前内部缓冲区长度为0或小于属性值时，每个read(n)扩展的函数Stream.Readable都会触发内部函数。_read(n)highWaterMark

2：仅当当前内部缓冲区长度为0或从内部缓冲区读取的数据为空或出现空指标readable时，才会触发该事件。

让我们以您的代码为例，看看发生了什么。

file.on('readable', function () {

事件处理程序寄存器将readable触发read(0)函数将数据从文件加载到内部缓冲区。如果不覆盖 的值highWaterMark，它最多会加载 64 * 1024 = 65535 个块。在您的代码中，它加载了文件“zeros.txt”中的所有数据。之后，它会触发事件，因为在函数调用readable之前内部缓冲区长度为 0 。read(0)

var data = file.read(10);

在处理程序中，您read(10)再次调用了函数。这也会触发从文件到缓冲区的加载过程。但是，此时不会加载任何数据。因此，null将被推送以指示读取过程已完成。第二个readable事件已被触发。这就是您应该看到并且只看到两个readable事件的原因。

如果您读取的文件大小大于 65535 字节（几乎 66KB），您应该只会看到一个readable事件被触发。

你不应该这样写readable事件处理程序，你应该参考以下内容：

var chunk;
while( null !== ( chunk = fs.read() ) ) {
    //handle the chunk
}

如果你想以自己的方式处理块做一些特殊的事情，请注意规则；否则，程序将停留在“暂停”状态，不再读取数据，也不再检索数据。

请参阅fs.ReadStream和stream.Readable。

于 2015-06-13T09:43:37.643 回答