Readable interface

É true depois 'close' que foi emitido.

closed: boolean

Valor da propriedade

É true depois readable.destroy() que foi chamado.

destroyed: boolean

Valor da propriedade

Retorna erro se o stream foi destruído com um erro.

errored: Error | null

Valor da propriedade

É true se for seguro chamar de read, o que significa que o fluxo não foi destruído ou emitido 'error' ou 'end'.

readable: boolean

Valor da propriedade

Retorna se o fluxo foi destruído ou cometeu erro antes de emitir 'end'.

readableAborted: boolean

Valor da propriedade

Retorna se 'data' foi emitido.

readableDidRead: boolean

Valor da propriedade

Getter para a propriedade encoding de um determinado Readable riacho. A encoding propriedade pode ser definida usando o método setCoding .

readableEncoding: BufferEncoding | null

Valor da propriedade

Torna-se true quando 'end' o evento é emitido.

readableEnded: boolean

Valor da propriedade

Essa propriedade reflete o estado atual de um Readable riacho conforme descrito na seção dos Três estados .

readableFlowing: boolean | null

Valor da propriedade

Retorna o valor de highWaterMark passado ao criar esse Readable.

readableHighWaterMark: number

Valor da propriedade

Essa propriedade contém o número de bytes (ou objetos) na fila prontos para serem lidos. O valor fornece dados de introspecção sobre o status do highWaterMark.

readableLength: number

Valor da propriedade

Getter para a propriedade objectMode de um determinado Readable riacho.

readableObjectMode: boolean

Valor da propriedade

function addListener(eventName: string | symbol, listener: (args: any[]) => void): this

Parâmetros

Retornos

Alias para emitter.on(eventName, listener).

function addListener<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parâmetros

Retornos

import { Readable } from 'node:stream';

async function* splitToWords(source) {
  for await (const chunk of source) {
    const words = String(chunk).split(' ');

    for (const word of words) {
      yield word;
    }
  }
}

const wordsStream = Readable.from(['text passed through', 'composed stream']).compose(splitToWords);
const words = await wordsStream.toArray();

console.log(words); // prints ['text', 'passed', 'through', 'composed', 'stream']

readable.compose(s) é equivalente a stream.compose(readable, s).

Esse método também permite que um AbortSignal seja fornecido, que destruirá o fluxo composto quando abortado.

Consulte stream.compose(...streams) para obter mais informações.

function compose(stream: WritableStream | WritableStream | TransformStream | (source: any) => void, options?: Abortable): Duplex

Parâmetros

Retornos

um fluxo composto pelo fluxo stream.

Destrua o fluxo. Opcionalmente, emita um 'error' evento e emita um 'close' evento (a menos que emitClose esteja definido como false). Após essa chamada, o fluxo legível liberará quaisquer recursos internos e as chamadas subsequentes push() serão ignoradas.

Uma vez destroy() chamada, quaisquer chamadas adicionais serão no-op e nenhum erro adicional, exceto from _destroy() pode ser emitido como 'error'.

Implementadores não devem sobrepor esse método, mas sim implementar readable._destroy().

function destroy(error?: Error): this

Parâmetros

Retornos

Esse método retorna um novo fluxo com os primeiros blocos de limite eliminados desde o início.

function drop(limit: number, options?: Abortable): Readable

Parâmetros

Retornos

um stream com blocos limite descartados desde o início.

function emit(eventName: string | symbol, args: any[]): boolean

Parâmetros

Retornos

Chama de forma síncrona cada um dos ouvintes registrados para o evento chamado eventName, na ordem em que foram registrados, passando os argumentos fornecidos para cada um.

Retorna true se o evento tiver ouvintes, false caso contrário.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

function emit<E>(eventName: E, args: ReadableEventMap[E]): boolean

Parâmetros

Retornos

Esse método é semelhante a Array.prototype.every e chama fn em cada bloco do fluxo para verificar se todos os valores de retorno aguardados são veridade para fn. Uma vez que uma chamada fn em um valor de retorno ed chunk awaité falsa, o fluxo é destruído e a promessa é cumprida com false. Se todas as chamadas fn nos chunks retornam um valor truthy, a promessa é cumprida com true.

function every(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>

Parâmetros

Retornos

Uma promessa avaliando se trueo FN devolveu um valor de verdade para cada um dos blocos.

Esse método permite filtrar o fluxo. Para cada pedaço no fluxo, a função fn será chamada e, se devolver um valor truthy, o pedaço será passado para o fluxo resultante. Se a função fn devolver uma promessa - essa promessa será awaited.

function filter(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: ReadableOperatorOptions): Readable

Parâmetros

Retornos

um fluxo filtrado com o predicado fn.

function find(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<any>

Parâmetros

Retornos

Esse método é semelhante a Array.prototype.find e chama fn em cada bloco do fluxo para encontrar um trecho com um valor truthy para fn. Uma vez que o valor de retorno aguardado de uma chamada fn é truthy, o fluxo é destruído e a promessa é cumprida com valor pelo qual fn retornou um valor truthy. Se todas as chamadas fn nos chunks devolverem um valor falso, a promessa é cumprida com undefined.

function find<T>(fn: (data: any, options?: Abortable) => data is T, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<T | undefined>

Parâmetros

Retornos

uma promessa avaliando até o primeiro bloco para o qual fn avaliou com um valor truthy, ou undefined se nenhum elemento foi encontrado.

Esse método retorna um novo fluxo aplicando o callback dado a cada pedaço do fluxo e então achatando o resultado.

É possível retornar um stream ou outro iterável iterável ou assíncrono a partir do fn e os fluxos resultantes serão fundidos (achatados) no fluxo retornado.

function flatMap(fn: (data: any, options?: Abortable) => any, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Readable

Parâmetros

Retornos

um fluxo mapeado planamente com a função fn.

Esse método permite iterar um fluxo. Para cada pedaço no fluxo, a função fn será chamada. Se a função fn devolver uma promessa - essa promessa será awaited.

Esse método é diferente dos for await...of loops porque pode processar chunks simultaneamente opcionalmente. Além disso, uma forEach iteração só pode ser interrompida se tiver passado uma signal opção e abortar o AbortController relacionado, enquanto for await...of pode ser parada com break ou return. Em qualquer dos casos, o riacho será destruído.

Esse método é diferente de ouvir o 'data' evento, pois utiliza o readable evento na máquina subjacente e pode limitar o número de chamadas fn concorrentes.

function forEach(fn: (data: any, options?: Abortable) => void | Promise<void>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<void>

Parâmetros

Retornos

uma promessa para quando a transmissão terminar.

O readable.isPaused() método retorna o estado operacional atual do Readable. Isso é usado principalmente pelo mecanismo que fundamenta o readable.pipe() método. Na maioria dos casos comuns, não haverá motivo para usar esse método diretamente.

const readable = new stream.Readable();

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

function isPaused(): boolean

Retornos

O iterador criado por esse método dá aos usuários a opção de cancelar a destruição do fluxo se o for await...of loop for encerrado por return, break, ou throw, ou se o iterador destruir o fluxo caso o fluxo emitisse um erro durante a iteração.

function iterator(options?: ReadableIteratorOptions): AsyncIterator<any>

Parâmetros

Retornos

function listenerCount(eventName: string | symbol, listener?: (args: any[]) => void): number

Parâmetros

Retornos

Retorna o número de ouvintes que escutam o evento chamado eventName. Se listener for fornecido, ele retornará quantas vezes o ouvinte é encontrado na lista de ouvintes do evento.

function listenerCount<E>(eventName: E, listener?: (args: ReadableEventMap[E]) => void): number

Parâmetros

Retornos

function listeners(eventName: string | symbol): (args: any[]) => void[]

Parâmetros

Retornos

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName.

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

function listeners<E>(eventName: E): (args: ReadableEventMap[E]) => void[]

Parâmetros

Retornos

Esse método permite mapear sobre o fluxo. A função fn será chamada para cada pedaço no fluxo. Se a função fn devolver uma promessa - essa promessa será awaited antes de ser passada para o fluxo de resultados.

function map(fn: (data: any, options?: Abortable) => any, options?: ReadableOperatorOptions): Readable

Parâmetros

Retornos

um fluxo mapeado com a função fn.

function off(eventName: string | symbol, listener: (args: any[]) => void): this

Parâmetros

Retornos

Alias para emitter.removeListener().

function off<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parâmetros

Retornos

function on(eventName: string | symbol, listener: (args: any[]) => void): this

Parâmetros

Retornos

Adiciona a função listener ao final da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

server.on('connection', (stream) => {
  console.log('someone connected!');
});

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function on<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parâmetros

Retornos

function once(eventName: string | symbol, listener: (args: any[]) => void): this

Parâmetros

Retornos

Adiciona uma função de única para o evento chamado . Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

Por padrão, os ouvintes de eventos são invocados na ordem em que são adicionados. O método emitter.prependOnceListener() pode ser usado como uma alternativa para adicionar o ouvinte de eventos ao início da matriz de ouvintes.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function once<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parâmetros

Retornos

O readable.pause() método fará com que um fluxo em modo de fluxo pare de emitir 'data' eventos, saindo do modo de fluxo. Qualquer dado que fique disponível permanecerá no buffer interno.

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

O readable.pause() método não tem efeito se houver um 'readable' ouvinte de eventos.

function pause(): this

Retornos

function prependListener(eventName: string | symbol, listener: (args: any[]) => void): this

Parâmetros

Retornos

Adiciona a função listener à inicial da matriz de ouvintes para o evento chamado eventName. Nenhuma verificação é feita para ver se o listener já foi adicionado. Várias chamadas passando a mesma combinação de eventName e listener resultarão na adição da listener e chamada várias vezes.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function prependListener<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parâmetros

Retornos

function prependOnceListener(eventName: string | symbol, listener: (args: any[]) => void): this

Parâmetros

Retornos

Adiciona uma função de única para o evento chamado à inicial da matriz de ouvintes. Na próxima vez que eventName for disparado, esse ouvinte será removido e invocado.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function prependOnceListener<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parâmetros

Retornos

function push(chunk: any, encoding?: BufferEncoding): boolean

Parâmetros

Retornos

function rawListeners(eventName: string | symbol): (args: any[]) => void[]

Parâmetros

Retornos

Retorna uma cópia da matriz de ouvintes para o evento chamado eventName, incluindo quaisquer wrappers (como aqueles criados por .once()).

import { EventEmitter } from 'node:events';
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');

function rawListeners<E>(eventName: E): (args: ReadableEventMap[E]) => void[]

Parâmetros

Retornos

O readable.read() método lê os dados do buffer interno e os retorna. Se nenhum dado estiver disponível para leitura, null é retornado. Por padrão, os dados são retornados como objeto Buffer , a menos que uma codificação tenha sido especificada usando o readable.setEncoding() método ou o fluxo esteja operando no modo objeto.

O argumento opcional size especifica um número específico de bytes a serem lidos. Se size bytes não estiverem disponíveis para leitura, null serão retornados, a menos que o fluxo tenha terminado, caso em que todos os dados restantes no buffer interno serão retornados.

Se o size argumento não for especificado, todos os dados contidos no buffer interno serão devolvidos.

O size argumento deve ser menor ou igual a 1 GiB.

O readable.read() método deve ser chamado apenas em Readable fluxos operando em modo pausado. No modo de fluxo, readable.read() é chamado automaticamente até que o buffer interno esteja totalmente drenado.

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

Cada chamada retorna readable.read() um pedaço de dados, ou null. Os chunks não são concatenados. Um while loop é necessário para consumir todos os dados atualmente no buffer. Ao ler, um arquivo .read() grande pode retornar null, tendo consumido todo o conteúdo armazenado até então, mas ainda há mais dados que ainda não estão armazenados. Nesse caso, um novo 'readable' evento será emitido quando houver mais dados no buffer. Finalmente, o 'end' evento será emitido quando não houver mais dados a serem divulgados.

Portanto, para ler todo o conteúdo de um arquivo a partir de um readable, é necessário coletar blocos de múltiplos 'readable' eventos:

const chunks = [];

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

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

Um Readable fluxo no modo objeto sempre retornará um único item de uma chamada para readable.read(size), independentemente do valor do size argumento.

Se o readable.read() método retornar um pedaço de dados, um 'data' evento também será emitido.

A chamada de leitura após a 'end' emissão do evento retornará null. Nenhum erro de execução será gerado.

function read(size?: number): any

Parâmetros

Retornos

Esse método chama fn em cada pedaço do fluxo em ordem, passando o resultado do cálculo no elemento anterior. Ele retorna uma promessa do valor final da redução.

Se nenhum valor inicial for fornecido, o primeiro trecho do fluxo é usado como valor inicial. Se o fluxo estiver vazio, a promessa é rejeitada com a TypeError com a ERR_INVALID_ARGS propriedade de código.

A função redutora itera o fluxo elemento por elemento, o que significa que não há parâmetro de concorrência ou paralelismo. Para realizar uma redução simultaneamente, você pode extrair a função assíncrona do método readable.map .

function reduce<T>(fn: (previous: any, data: any, options?: Abortable) => T): Promise<T>

Parâmetros

Retornos

uma promessa do valor final da redução.

function reduce<T>(fn: (previous: T, data: any, options?: Abortable) => T, initial: T, options?: Abortable): Promise<T>

Parâmetros

Retornos

function removeAllListeners(eventName?: string | symbol): this

Parâmetros

Retornos

Remove todos os ouvintes ou os do eventNameespecificado.

É uma má prática remover ouvintes adicionados em outro lugar no código, especialmente quando a instância de EventEmitter foi criada por algum outro componente ou módulo (por exemplo, soquetes ou fluxos de arquivo).

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function removeAllListeners<E>(eventName?: E): this

Parâmetros

Retornos

function removeListener(eventName: string | symbol, listener: (args: any[]) => void): this

Parâmetros

Retornos

Remove o listener especificado da matriz de ouvintes para o evento chamado eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

removeListener() removerá, no máximo, uma instância de um ouvinte da matriz do ouvinte. Se qualquer ouvinte tiver sido adicionado várias vezes à matriz de ouvintes para o eventNameespecificado, removeListener() deverá ser chamado várias vezes para remover cada instância.

Depois que um evento é emitido, todos os ouvintes anexados a ele no momento da emissão são chamados em ordem. Isso implica que qualquer removeListener() chamada removeAllListeners() após a emissão e antes da execução do último ouvinte não as remove do emit() processo em andamento. Os eventos subsequentes se comportam conforme o esperado.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

Como os ouvintes são gerenciados usando um array interno, chamar isso altera os índices de posição de qualquer ouvinte registrado após a remoção do ouvinte. Isso não afetará a ordem na qual os ouvintes são chamados, mas significa que todas as cópias da matriz do ouvinte, conforme retornado pelo método emitter.listeners(), precisarão ser recriadas.

Quando uma única função tiver sido adicionada como um manipulador várias vezes para um único evento (como no exemplo abaixo), removeListener() removerá a instância adicionada mais recentemente. No exemplo, o ouvinte once('ping') é removido:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function removeListener<E>(eventName: E, listener: (args: ReadableEventMap[E]) => void): this

Parâmetros

Retornos

O readable.resume() método faz com que um fluxo explicitamente Readable pausado retome a 'data' emissão de eventos, mudando o fluxo para o modo de fluxo.

O readable.resume() método pode ser usado para consumir totalmente os dados de um fluxo sem realmente processar nenhum desses dados:

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

O readable.resume() método não tem efeito se houver um 'readable' ouvinte de eventos.

function resume(): this

Retornos

O readable.setEncoding() método define a codificação de caracteres para dados lidos do Readable fluxo.

Por padrão, nenhuma codificação é atribuída e os dados do fluxo serão retornados como Buffer objetos. Definir uma codificação faz com que os dados do fluxo sejam retornados como cadeias da codificação especificada, em vez de como Buffer objetos. Por exemplo, chamar readable.setEncoding('utf8') fará com que os dados de saída sejam interpretados como dados UTF-8 e passados como strings. Chamar readable.setEncoding('hex') fará com que os dados sejam codificados em formato hexadecimal de string.

O Readable fluxo lida corretamente com caracteres de múltiplos bytes entregues pelo fluxo que, de outra forma, seriam decodificados de forma incorreta se simplesmente puxados do fluxo como Buffer objetos.

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

function setEncoding(encoding: BufferEncoding): this

Parâmetros

Retornos

Esse método é semelhante a Array.prototype.some e chama fn em cada pedaço do fluxo até que o valor de retorno aguardado seja true (ou qualquer valor truthy). Uma vez que uma chamada fn em um valor de retorno de chunk awaited é vera, o fluxo é destruído e a promessa é cumprida com true. Se nenhuma das chamadas de fn nos chunks devolver um valor truthy, a promessa é cumprida com false.

function some(fn: (data: any, options?: Abortable) => boolean | Promise<boolean>, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<boolean>

Parâmetros

Retornos

Uma promessa avaliando se trueo FN retornou um valor de verdade para pelo menos um dos blocos.

Esse método retorna um novo fluxo com os primeiros blocos limite .

function take(limit: number, options?: Abortable): Readable

Parâmetros

Retornos

um stream com blocos limite ocupados.

Esse método permite obter facilmente o conteúdo de um fluxo.

Como esse método lê todo o fluxo na memória, anula os benefícios dos fluxos. Ele é pensado para interoperabilidade e conveniência, não como a principal forma de consumir streams.

function toArray(options?: Abortable): Promise<any[]>

Parâmetros

Retornos

uma promessa contendo um array com o conteúdo do fluxo.

O readable.unpipe() método desprende um Writable fluxo de água previamente conectado usando o método do tubo .

Se o destination não for especificado, então todos os tubos são destacados.

Se o destination for especificado, mas nenhum tubo for configurado para isso, então o método não faz nada.

import fs from 'node: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);

function unpipe(destination?: WritableStream): this

Parâmetros

Retornos

Passar chunk como null sinaliza o fim do fluxo (EOF) e se comporta da mesma forma que readable.push(null), após o qual não é possível mais escrever dados. O sinal EOF é colocado no final do buffer e quaisquer dados armazenados ainda serão esvaziados.

O readable.unshift() método empurra um pedaço de dados de volta para o buffer interno. Isso é útil em certas situações em que um fluxo está sendo consumido por código que precisa "desconsumir" uma quantidade de dados que ele retirou otimisticamente da fonte, para que os dados possam ser repassados para outra parte.

O stream.unshift(chunk) método não pode ser chamado após o 'end' evento ter sido emitido ou um erro em tempo de execução será lançado.

Desenvolvedores que usam stream.unshift() frequentemente devem considerar mudar para o uso de um Transform stream. Veja a API for stream implementers seção para mais informações.

// Pull off a header delimited by \n\n.
// Use unshift() if we get too much.
// Call the callback with (error, header, stream).
import { StringDecoder } from 'node: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;
    }
  }
}

Ao contrário do push, não stream.unshift(chunk) encerra o processo de leitura ao resetar o estado interno de leitura do fluxo. Isso pode causar resultados inesperados se readable.unshift() for chamado durante uma leitura (ou seja, de dentro de uma implementação _read em um fluxo personalizado). Seguir a chamada com readable.unshift() um push imediato resetará o estado de leitura adequadamente, porém é melhor simplesmente evitar ligar readable.unshift() durante o processo de leitura.

function unshift(chunk: any, encoding?: BufferEncoding)

Parâmetros

Antes do Node.js 0.10, os streams não implementavam toda node:stream a API do módulo como ela está definida atualmente. (Veja Compatibility para mais informações.)

Ao usar uma biblioteca Node.js antiga que emite 'data' eventos e possui um método de pausa apenas consultivo, o readable.wrap() método pode ser usado para criar um Readable fluxo que usa o fluxo antigo como fonte de dados.

Raramente será necessário usá-lo readable.wrap() , mas o método foi oferecido como uma conveniência para interagir com aplicativos e bibliotecas Node.js mais antigos.

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

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

function wrap(stream: ReadableStream): this

Parâmetros

Retornos

Liga readable.destroy() com um AbortError e retorna uma promessa que se cumpre quando a transmissão termina.

function [asyncDispose](): Promise<void>

Retornos

function [asyncIterator](): AsyncIterator<any>

Retornos

AsyncIterator para consumir totalmente o fluxo.

Quando a --experimental-stream-iter flag está ativada, Readable os fluxos implementam o Stream.toAsyncStreamable protocolo, permitindo um consumo eficiente pela stream/iter API.

Isso fornece um iterador assíncrono em lote que drena o buffer interno do fluxo em Uint8Array[] lotes, amortizando a sobrecarga Promise por bloco do caminho padrão Symbol.asyncIterator . Para fluxos em modo byte, chunks são fornecidos diretamente como Buffer instâncias (que são Uint8Array subclasses). Para fluxos em modo objeto ou codificados, cada bloco é normalizado para Uint8Array antes do loteamento.

O iterador retornado é marcado como fonte validada, então from() o passa sem normalização adicional.

import { Readable } from 'node:stream';
import { text, from } from 'node:stream/iter';

const readable = new Readable({
  read() { this.push('hello'); this.push(null); },
});

// Readable is automatically consumed via toAsyncStreamable
console.log(await text(from(readable))); // 'hello'

Sem a --experimental-stream-iter flag, chamar esse método lança ERR_STREAM_ITER_MISSING_FLAG.

function [toAsyncStreamable](): ByteReadableStream

Retornos

Retorna uma matriz listando os eventos para os quais o emissor registrou ouvintes.

import { EventEmitter } from 'node: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) ]

function eventNames(): (string | symbol)[]

Retornos

Herdado de Stream.eventNames

Retorna o valor máximo atual do ouvinte para o EventEmitter que é definido por emitter.setMaxListeners(n) ou usa como padrão events.defaultMaxListeners.

function getMaxListeners(): number

Retornos

Herdado de Stream.getMaxListeners

function pipe<T>(destination: T, options?: PipeOptions): T

Parâmetros

Retornos

Herdado de Stream.pipe

Por padrão, EventEmitterimprimirão um aviso se mais de 10 ouvintes forem adicionados para um evento específico. Esse é um padrão útil que ajuda a localizar vazamentos de memória. O método emitter.setMaxListeners() permite que o limite seja modificado para esta instância de EventEmitter específica. O valor pode ser definido como Infinity (ou 0) para indicar um número ilimitado de ouvintes.

Retorna uma referência ao EventEmitter, para que as chamadas possam ser encadeadas.

function setMaxListeners(n: number): this

Parâmetros

Retornos

Herdado de Stream.setMaxOuvintes

O Symbol.for('nodejs.rejection') método é chamado caso ocorra uma rejeição de promessa ao emitir um evento e captureRejections é ativado no emissor. É possível usar events.captureRejectionSymbol no lugar de Symbol.for('nodejs.rejection').

import { EventEmitter, captureRejectionSymbol } from 'node:events';

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

Parâmetros

Herdado de Stream. [capturaRejeiçãoSímbolo]