Class GridFSBucketReadStream

Once destroy() has been called any further calls will be a no-op and no further errors except from _destroy() may be emitted as 'error'.一旦调用destroy()，任何进一步的调用都将是no-op，并且除了_destroy()之外，其他错误都不会作为'error'发出。

Implementors should not override this method, but instead implement readable._destroy().实现者不应重写此方法，而应实现readable._destroy()。

const EventEmitter = require('events');
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

const readable = new stream.Readable();

readable.isPaused(); // === false
readable.pause();
readable.isPaused(); // === true
readable.resume();
readable.isPaused(); // === false

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

const readable = getReadableStreamSomehow();
readable.on('data', (chunk) => {
  console.log(Received ${chunk.length} bytes of data.);
  readable.pause();
  console.log('There will be no additional data for 1 second.');
  setTimeout(() => {
    console.log('Now data will start flowing again.');
    readable.resume();
  }, 1000);
});

The readable.pause() method has no effect if there is a 'readable'event listener.如果存在'readable'事件侦听器，readable.pause()方法将无效。

const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function onceWrapper which has a property
// listener which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the once event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by .on() above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

The optional size argument specifies a specific number of bytes to read. 可选的size参数指定要读取的特定字节数。If size bytes are not available to be read, null will be returned unlessthe stream has ended, in which case all of the data remaining in the internal buffer will be returned.如果无法读取size字节，则将返回null 除非流已结束，在这种情况下，将返回内部缓冲区中剩余的所有数据。

If the size argument is not specified, all of the data contained in the internal buffer will be returned.如果未指定size参数，则将返回内部缓冲区中包含的所有数据。

The size argument must be less than or equal to 1 GiB.size参数必须小于或等于1 GiB。

The readable.read() method should only be called on Readable streams operating in paused mode. readable.read()方法只应在暂停模式下运行的Readable流上调用。In flowing mode, readable.read() is called automatically until the internal buffer is fully drained.在流动模式下，会自动调用readable.read()，直到内部缓冲区完全耗尽。

const readable = getReadableStreamSomehow();

// 'readable' may be triggered multiple times as data is buffered in
readable.on('readable', () => {
  let chunk;
  console.log('Stream is readable (new data received in buffer)');
  // Use a loop to make sure we read all currently available data
  while (null !== (chunk = readable.read())) {
    console.log(Read ${chunk.length} bytes of data...);
  }
});

// 'end' will be triggered once when there is no more data available
readable.on('end', () => {
  console.log('Reached end of stream.');
});

Each call to readable.read() returns a chunk of data, or null. 每次调用readable.read()都会返回一块数据，或为null。The chunks are not concatenated. 块未连接。A while loop is necessary to consume all data currently in the buffer. 需要while循环来消耗缓冲区中当前的所有数据。When reading a large file .read() may return null, having consumed all buffered content so far, but there is still more data to come not yet buffered. 读取大文件时，.read()可能会返回null，因为到目前为止已经消耗了所有缓冲的内容，但还有更多数据尚未缓冲。In this case a new 'readable' event will be emitted when there is more data in the buffer. 在这种情况下，当缓冲区中有更多数据时，将发出一个新的'readable'事件。Finally the 'end' event will be emitted when there is no more data to come.最后，当没有更多数据时，将发出'end'事件。

Therefore to read a file's whole contents from a readable, it is necessary to collect chunks across multiple 'readable' events:因此，要从readable文件中读取文件的全部内容，需要跨多个'readable'事件集合块：

const chunks = [];

readable.on('readable', () => {
  let chunk;
  while (null !== (chunk = readable.read())) {
    chunks.push(chunk);
  }
});

readable.on('end', () => {
  const content = chunks.join('');
});

A Readable stream in object mode will always return a single item from a call to readable.read(size), regardless of the value of thesize argument.对象模式下的Readable流将始终从对readable.read(size)的调用返回单个项，而不管size参数的值如何。

If the readable.read() method returns a chunk of data, a 'data' event will also be emitted.如果readable.read()方法返回一个数据块，则也会发出'data'事件。

Calling read after the 'end' event has been emitted will return null. 在发出'end'事件后调用read将返回null。No runtime error will be raised.不会引发运行时错误。

It is bad practice to remove listeners added elsewhere in the code, particularly when the EventEmitter instance was created by some other component or module (e.g. sockets or file streams).删除代码中其他地方添加的侦听器是一种糟糕的做法，尤其是当EventEmitter实例由其他组件或模块（例如套接字或文件流）创建时。

Returns a reference to the EventEmitter, so that calls can be chained.返回对EventEmitter的引用，以便可以链接调用。

The readable.resume() method can be used to fully consume the data from a stream without actually processing any of that data:readable.resume()方法可用于完全消耗流中的数据，而无需实际处理任何数据：

getReadableStreamSomehow()
  .resume()
  .on('end', () => {
    console.log('Reached the end, but did not read anything.');
  });

The readable.resume() method has no effect if there is a 'readable'event listener.如果存在'readable'事件侦听器，则readable.resume()方法无效。

By default, no encoding is assigned and stream data will be returned asBuffer objects. 默认情况下，不分配编码，流数据将作为Buffer对象返回。Setting an encoding causes the stream data to be returned as strings of the specified encoding rather than as Bufferobjects. 设置编码会导致流数据作为指定编码的字符串而不是作为Buffer对象返回。For instance, calling readable.setEncoding('utf8') will cause the output data to be interpreted as UTF-8 data, and passed as strings. 例如，调用readable.setEncoding('utf8')将导致输出数据被解释为UTF-8数据，并作为字符串传递。Callingreadable.setEncoding('hex') will cause the data to be encoded in hexadecimal string format.调用readable.setEncoding('hex')将导致数据以十六进制字符串格式编码。

The Readable stream will properly handle multi-byte characters delivered through the stream that would otherwise become improperly decoded if simply pulled from the stream as Buffer objects.Readable流将正确处理通过流传递的多字节字符，否则，如果将这些字符作为Buffer对象从流中提取，这些字符将被不正确地解码。

const readable = getReadableStreamSomehow();
readable.setEncoding('utf8');
readable.on('data', (chunk) => {
  assert.equal(typeof chunk, 'string');
  console.log('Got %d characters of string data:', chunk.length);
});

Returns a reference to the EventEmitter, so that calls can be chained.返回对EventEmitter的引用，以便可以链接调用。

If the destination is not specified, then all pipes are detached.如果未指定destination，则将分离所有管道。

If the destination is specified, but no pipe is set up for it, then the method does nothing.如果指定了destination，但没有为其设置管道，则该方法不执行任何操作。

const fs = require('fs');
const readable = getReadableStreamSomehow();
const writable = fs.createWriteStream('file.txt');
// All the data from readable goes into 'file.txt',
// but only for the first second.
readable.pipe(writable);
setTimeout(() => {
  console.log('Stop writing to file.txt.');
  readable.unpipe(writable);
  console.log('Manually close the file stream.');
  writable.end();
}, 1000);

The readable.unshift() method pushes a chunk of data back into the internal buffer. readableun.shift()方法将一块数据推回到内部缓冲区。This is useful in certain situations where a stream is being consumed by code that needs to "un-consume" some amount of data that it has optimistically pulled out of the source, so that the data can be passed on to some other party.这在某些情况下很有用，因为流被代码消耗，代码需要“取消消耗”从源中乐观地提取的一些数据，以便数据可以传递给其他方。

The stream.unshift(chunk) method cannot be called after the 'end' event has been emitted or a runtime error will be thrown.stream.unshift(chunk)方法无法在发出'end'事件后调用，否则将引发运行时错误。

Developers using stream.unshift() often should consider switching to use of a Transform stream instead. 使用stream.unshift()的开发人员通常应该考虑改用Transform流。See the API for stream implementers section for more information.有关更多信息，请参阅“流实现器的API”部分。

// Pull off a header delimited by \n\n.
// Use unshift() if we get too much.
// Call the callback with (error, header, stream).
const { StringDecoder } = require('string_decoder');
function parseHeader(stream, callback) {
  stream.on('error', callback);
  stream.on('readable', onReadable);
  const decoder = new StringDecoder('utf8');
  let header = '';
  function onReadable() {
    let chunk;
    while (null !== (chunk = stream.read())) {
      const str = decoder.write(chunk);
      if (str.includes('\n\n')) {
        // Found the header boundary.
        const split = str.split(/\n\n/);
        header += split.shift();
        const remaining = split.join('\n\n');
        const buf = Buffer.from(remaining, 'utf8');
        stream.removeListener('error', callback);
        // Remove the 'readable' listener before unshifting.
        stream.removeListener('readable', onReadable);
        if (buf.length)
          stream.unshift(buf);
        // Now the body of the message can be read from the stream.
        callback(null, header, stream);
        return;
      }
      // Still reading the header.
      header += str;
    }
  }
}

Unlike push, stream.unshift(chunk) will not end the reading process by resetting the internal reading state of the stream. 与push不同，stream.unshift(chunk)不会通过重置流的内部读取状态来结束读取过程。This can cause unexpected results if readable.unshift() is called during a read (i.e. from within a {@link _read} implementation on a custom stream). 如果在读取过程中调用code>readable.unshift()（即从自定义流的read实现中调用），这可能会导致意外结果。Following the call to readable.unshift() with an immediate push will reset the reading state appropriately, however it is best to simply avoid calling readable.unshift() while in the process of performing a read.立即按下对readable.unshift()的调用将适当地重置读取状态，但最好在执行读取过程中避免调用readable.unhift()。

When using an older Node.js library that emits 'data' events and has a pause method that is advisory only, thereadable.wrap() method can be used to create a Readable stream that uses the old stream as its data source.当使用一个旧的Node.js库，该库发出'data'事件，并且有一个暂停方法（仅为建议）时，可以使用readable.wrap()方法创建一个使用旧流作为数据源的Readable流。

It will rarely be necessary to use readable.wrap() but the method has been provided as a convenience for interacting with older Node.js applications and libraries.很少需要使用readable.wrap()，但提供该方法是为了方便与旧的Node.js应用程序和库进行交互。

const { OldReader } = require('./old-api-module.js');
const { Readable } = require('stream');
const oreader = new OldReader();
const myReader = new Readable().wrap(oreader);

myReader.on('readable', () => {
  myReader.read(); // etc.
});