Readable class

Pacote:
@azure/storage-common
Extends

Stream

Construtores

Readable(ReadableOptions<Readable>)

Propriedades

closed

É true depois 'close' de ter sido emitido.
destroyed

É true depois readable.destroy() de ter sido chamado.
errored

Devolve erro se o fluxo tiver sido destruído com um erro.
readable

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

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

Devolve se 'data' foi emitido.
readableEncoding

Getter para a propriedade encoding de um dado Readable riacho. A encoding propriedade pode ser definida usando o método setEncoding .
readableEnded

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

Esta propriedade reflete o estado atual de um Readable curso de água conforme descrito na secção dos Três estados .
readableHighWaterMark

Devolve o valor de highWaterMark passado ao criar este Readable.
readableLength

Esta propriedade contém o número de bytes (ou objetos) na fila prontos para serem lidos. O valor fornece dados de introspeção relativamente ao estado do highWaterMark.
readableObjectMode

Getter para a propriedade objectMode de um dado Readable riacho.

Métodos

addListener(string | symbol, (args: any[]) => void)
addListener<E>(E, (args: ReadableEventMap[E]) => void)
compose(WritableStream | WritableStream<any> | TransformStream<any, any> | (source: any) => void, Abortable) 
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).

Este método também permite fornecer um AbortSignal , que destruirá o fluxo composto quando abortado.

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

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

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

Os implementadores não devem sobrepor este método, mas sim implementar readable._destroy().
drop(number, Abortable)

Este método devolve um novo fluxo com os primeiros blocos de limite eliminados desde o início.
emit(string | symbol, any[])
emit<E>(E, ReadableEventMap[E])
every((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Este 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 valores truthy para fn. Uma vez que uma chamada fn num valor de retorno ed awaitchunk for falsa, o fluxo é destruído e a promessa é cumprida com false. Se todas as chamadas fn nos chunks devolverem um valor truthy, a promessa é cumprida com true.
filter((data: any, options?: Abortable) => boolean | Promise<boolean>, ReadableOperatorOptions)

Este método permite filtrar o fluxo. Para cada chunk no fluxo, a função fn será chamada e, se devolver um valor truthy, o chunk será passado para o fluxo resultante. Se a função fn devolver uma promessa – essa promessa será awaited.
find((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)
find<T>((data: any, options?: Abortable) => data, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Este método é semelhante a Array.prototype.find e chama fn em cada bloco do fluxo para encontrar um bloco com um valor truthy para fn. Quando o valor de retorno aguardado de uma chamada fn é truthy, o stream é destruído e a promessa é cumprida com valor para o qual fn devolveu um valor truthy. Se todas as chamadas fn nos chunks devolverem um valor falso, a promessa é cumprida com undefined.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Este método devolve um novo fluxo aplicando o callback dado a cada bloco do fluxo e depois achatando o resultado.

É possível devolver um fluxo ou outro iterável iterável ou assíncrono a partir do fn e os fluxos resultantes serão fundidos (achatados) no fluxo devolvido.
forEach((data: any, options?: Abortable) => void | Promise<void>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

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

Este método é diferente dos for await...of loops porque pode, opcionalmente, processar chunks em simultâneo. Além disso, uma forEach iteração só pode ser interrompida passando uma signal opção e abortando o AbortController relacionado, enquanto for await...of pode ser interrompida com break ou return. Em qualquer dos casos, o riacho será destruído.

Este método difere de ouvir o 'data' evento, pois utiliza o readable evento na maquinaria subjacente e pode limitar o número de chamadas fn simultâneas.
from(Iterable<any> | AsyncIterable<any>, ReadableOptions<Readable>)

Um método utilitário para criar Fluxos Legíveis a partir de iteradores.
fromWeb(ReadableStream<any>, Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">)

Um método utilitário para criar um Readable a partir de uma web ReadableStream.
isDisturbed(ReadableStream<any> | ReadableStream)

Devolve se a transmissão foi lida ou cancelada.
isPaused()

O readable.isPaused() método devolve o estado operacional atual do Readable. Isto é usado principalmente pelo mecanismo que sustenta o readable.pipe() método. Na maioria dos casos típicos, não haverá razão para usar este método diretamente.

const readable = new stream.Readable();

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

O iterador criado por este método dá aos utilizadores a opção de cancelar a destruição do fluxo se o for await...of ciclo for encerrado por return, break, ou throw, ou se o iterador destruir o fluxo caso este emitisse um erro durante a iteração.
listenerCount(string | symbol, (args: any[]) => void)
listenerCount<E>(E, (args: ReadableEventMap[E]) => void)
listeners(string | symbol)
listeners<E>(E)
map((data: any, options?: Abortable) => any, ReadableOperatorOptions)

Este método permite mapear sobre o riacho. A função fn será chamada para cada bloco do fluxo. Se a função fn devolver uma promessa - essa promessa será awaited antes de ser passada para o fluxo de resultados.
off(string | symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)
on(string | symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)
once(string | symbol, (args: any[]) => void)
once<E>(E, (args: ReadableEventMap[E]) => void)
pause()

O readable.pause() método fará com que um fluxo em modo de fluxo pare de emitir 'data' eventos, saindo do modo de fluxo. Quaisquer dados que fiquem disponíveis permanecerão 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.
prependListener(string | symbol, (args: any[]) => void)
prependListener<E>(E, (args: ReadableEventMap[E]) => void)
prependOnceListener(string | symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)
push(any, BufferEncoding)
rawListeners(string | symbol)
rawListeners<E>(E)
read(number)

O readable.read() método lê dados do buffer interno e devolve-os. Se não houver dados disponíveis para leitura, null é devolvido. Por defeito, os dados são devolvidos como objeto Buffer , a menos que uma codificação tenha sido especificada usando o readable.setEncoding() método ou que o fluxo esteja a operar em modo objeto.

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

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 que operam 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 para readable.read() devolve um bloco de dados, ou null. Os chunks não são concatenados. É necessário um while ciclo para consumir todos os dados atualmente no buffer. Ao ler, um ficheiro .read() grande pode devolver null, tendo consumido todo o conteúdo armazenado até agora, mas ainda há mais dados por vir, ainda não armazenados. Neste 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 disponíveis.

Portanto, para ler todo o conteúdo de um ficheiro a partir de um readable, é necessário recolher 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 em modo objeto devolverá sempre um único item de uma chamada para readable.read(size), independentemente do valor do size argumento.

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

A chamada de leitura após o 'end' evento ter sido emitido retornará null. Não será apresentado nenhum erro de execução.
reduce<T>((previous: any, data: any, options?: Abortable) => T)

Este método chama fn em cada bloco do fluxo por ordem, passando-lhe o resultado do cálculo no elemento anterior. Devolve uma promessa do valor final da redução.

Se não for fornecido valor inicial , o primeiro bloco do fluxo é usado como valor inicial. Se o fluxo estiver vazio, a promessa é rejeitada com a TypeErrorERR_INVALID_ARGS propriedade de código.

A função redutora itera o fluxo elemento a elemento, o que significa que não existe parâmetro de concorrência nem paralelismo. Para realizar uma redução simultaneamente, pode extrair a função assíncrona do readable.map método.
reduce<T>((previous: T, data: any, options?: Abortable) => T, T, Abortable)
removeAllListeners(string | symbol)
removeAllListeners<E>(E)
removeListener(string | symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)
resume()

O readable.resume() método faz com que um fluxo explicitamente Readable pausado retome a 'data' emissão de eventos, mudando o fluxo para 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.
setEncoding(BufferEncoding)

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

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

O Readable fluxo lida corretamente com caracteres multibyte entregues através do fluxo que, de outra forma, seriam decodificados incorretamente 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);
});
some((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Este método é semelhante a Array.prototype.some e chama fn em cada bloco do fluxo até que o valor de retorno aguardado seja true (ou qualquer valor truthy). Uma vez que uma chamada fn num valor de retorno de chunk awaited é verdadeira, o fluxo é destruído e a promessa é cumprida com true. Se nenhum dos fn calls nos chunks devolver um valor truthy, a promessa é cumprida com false.
take(number, Abortable)

Este método devolve um novo fluxo com os primeiros blocos limite .
toArray(Abortable)

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

Como este método lê todo o fluxo na memória, anula os benefícios dos fluxos. Destina-se à interoperabilidade e conveniência, não a principal forma de consumir streams.
toWeb(ReadableStream, ReadableToWebOptions)

Um método utilitário para criar uma teia ReadableStream a partir de um Readable.
unpipe(WritableStream)

O readable.unpipe() método destaca um Writable jato previamente ligado 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 não estiver configurado nenhum tubo 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);
unshift(any, BufferEncoding)

Passar chunk como null sinaliza o fim do fluxo (EOF) e comporta-se da mesma forma que readable.push(null), após o que não podem ser escritos mais dados. O sinal EOF é colocado no final do buffer e quaisquer dados armazenados em buffer continuam a ser eliminados.

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

O stream.unshift(chunk) método não pode ser chamado depois de o 'end' evento ter sido emitido, caso contrário será lançado um erro em tempo de execução.

Os programadores que usam stream.unshift() frequentemente devem considerar mudar para o uso de um Transform stream em vez disso. Consulte a API for stream implementers secçã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, stream.unshift(chunk) não termina o processo de leitura ao reiniciar o estado interno de leitura do fluxo. Isto pode causar resultados inesperados se readable.unshift() for chamado durante uma leitura (ou seja, a partir de uma implementação _read num fluxo personalizado). Seguir a chamada readable.unshift() com um push imediato irá reiniciar o estado de leitura corretamente, no entanto, é melhor simplesmente evitar ligar readable.unshift() durante o processo de leitura.
wrap(ReadableStream)

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

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

Raramente será necessário utilizá-lo readable.wrap() , mas o método foi disponibilizado como uma conveniência para interagir com aplicações e bibliotecas Node.js mais antigas.

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.
});
[asyncIterator]()

Métodos Herdados

eventNames()

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) ]
getMaxListeners()

Retorna o valor máximo de ouvinte atual para o EventEmitter que é definido por emitter.setMaxListeners(n) ou padrão como events.defaultMaxListeners.
pipe<T>(T, PipeOptions)
setMaxListeners(number)

Por padrãoEventEmitters imprimirá um aviso se mais de 10 ouvintes forem adicionados para um evento específico. Este é um padrão útil que ajuda a encontrar vazamentos de memória. O método emitter.setMaxListeners() permite que o limite seja modificado para esta instância 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.
[captureRejectionSymbol](Error, string | symbol, any[])

O Symbol.for('nodejs.rejection') método é chamado caso ocorra uma rejeição de promessa ao emitir um evento e captureRejections está ativado no emissor. É possível usar events.captureRejectionSymbol em vez 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.
  }
}

Detalhes do Construtor

Readable(ReadableOptions<Readable>) 

new Readable(options?: ReadableOptions<Readable>)

Parâmetros

options

ReadableOptions<Readable>

Detalhes de Propriedade

closed

É true depois 'close' de ter sido emitido.

closed: boolean

Valor de Propriedade

boolean

destroyed

É true depois readable.destroy() de ter sido chamado.

destroyed: boolean

Valor de Propriedade

boolean

errored

Devolve erro se o fluxo tiver sido destruído com um erro.

errored: null | Error

Valor de Propriedade

null | Error

readable

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

readable: boolean

Valor de Propriedade

boolean

readableAborted

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

readableAborted: boolean

Valor de Propriedade

boolean

readableDidRead

Devolve se 'data' foi emitido.

readableDidRead: boolean

Valor de Propriedade

boolean

readableEncoding

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

readableEncoding: null | BufferEncoding

Valor de Propriedade

null | BufferEncoding

readableEnded

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

readableEnded: boolean

Valor de Propriedade

boolean

readableFlowing

Esta propriedade reflete o estado atual de um Readable curso de água conforme descrito na secção dos Três estados .

readableFlowing: null | boolean

Valor de Propriedade

null | boolean

readableHighWaterMark

Devolve o valor de highWaterMark passado ao criar este Readable.

readableHighWaterMark: number

Valor de Propriedade

number

readableLength

Esta propriedade contém o número de bytes (ou objetos) na fila prontos para serem lidos. O valor fornece dados de introspeção relativamente ao estado do highWaterMark.

readableLength: number

Valor de Propriedade

number

readableObjectMode

Getter para a propriedade objectMode de um dado Readable riacho.

readableObjectMode: boolean

Valor de Propriedade

boolean

Detalhes de Método

addListener(string | symbol, (args: any[]) => void) 

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluções

Readable

addListener<E>(E, (args: ReadableEventMap[E]) => void) 

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

Parâmetros

eventName

E

listener

(args: ReadableEventMap[E]) => void

Devoluções

Readable

compose(WritableStream | WritableStream<any> | TransformStream<any, any> | (source: any) => void, Abortable) 

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

Este método também permite fornecer um AbortSignal , que destruirá o fluxo composto quando abortado.

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

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

Parâmetros

stream

WritableStream | WritableStream<any> | TransformStream<any, any> | (source: any) => void

options

Abortable

Devoluções

Duplex

um curso de água composto pelo fluxo stream.

destroy(Error)

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

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

Os implementadores não devem sobrepor este método, mas sim implementar readable._destroy().

function destroy(error?: Error): Readable

Parâmetros

error

Error

Erro que será transmitido como carga útil em 'error' caso de

Devoluções

Readable

drop(number, Abortable)

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

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

Parâmetros

limit

number

O número de blocos a eliminar do legível.

options

Abortable

Devoluções

Readable

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

emit(string | symbol, any[]) 

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

Parâmetros

eventName

string | symbol

args

any[]

Devoluções

boolean

emit<E>(E, ReadableEventMap[E]) 

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

Parâmetros

eventName

E

args

ReadableEventMap[E]

Devoluções

boolean

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

Este 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 valores truthy para fn. Uma vez que uma chamada fn num valor de retorno ed awaitchunk for falsa, o fluxo é destruído e a promessa é cumprida com false. Se todas as chamadas fn nos chunks devolverem um valor truthy, a promessa é cumprida com true.

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

Parâmetros

fn

(data: any, options?: Abortable) => boolean | Promise<boolean>

uma função para chamar cada pedaço do fluxo. Assíncrono ou não.

options

Pick<ReadableOperatorOptions, "signal" | "concurrency">

Devoluções

Promise<boolean>

Uma promessa que avalia se truea FN devolveu um valor de verdade para cada um dos blocos.

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

Este método permite filtrar o fluxo. Para cada chunk no fluxo, a função fn será chamada e, se devolver um valor truthy, o chunk 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

fn

(data: any, options?: Abortable) => boolean | Promise<boolean>

uma função para filtrar blocos do fluxo. Assíncrono ou não.

options

ReadableOperatorOptions

Devoluções

Readable

um fluxo filtrado com o predicado fn.

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

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

Parâmetros

fn

(data: any, options?: Abortable) => boolean | Promise<boolean>

options

Pick<ReadableOperatorOptions, "signal" | "concurrency">

Devoluções

Promise<any>

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

Este método é semelhante a Array.prototype.find e chama fn em cada bloco do fluxo para encontrar um bloco com um valor truthy para fn. Quando o valor de retorno aguardado de uma chamada fn é truthy, o stream é destruído e a promessa é cumprida com valor para o qual fn devolveu 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, options?: Pick<ReadableOperatorOptions, "signal" | "concurrency">): Promise<undefined | T>

Parâmetros

fn

(data: any, options?: Abortable) => data

uma função para chamar cada pedaço do fluxo. Assíncrono ou não.

options

Pick<ReadableOperatorOptions, "signal" | "concurrency">

Devoluções

Promise<undefined | T>

uma promessa avaliada para o primeiro bloco para o qual fn avaliou com um valor truthy, ou undefined se não foi encontrado nenhum elemento.

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

Este método devolve um novo fluxo aplicando o callback dado a cada bloco do fluxo e depois achatando o resultado.

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

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

Parâmetros

fn

(data: any, options?: Abortable) => any

uma função para mapear cada bloco do fluxo. Pode ser assíncrono. Pode ser um fluxo de água ou gerador.

options

Pick<ReadableOperatorOptions, "signal" | "concurrency">

Devoluções

Readable

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

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

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

Este método é diferente dos for await...of loops porque pode, opcionalmente, processar chunks em simultâneo. Além disso, uma forEach iteração só pode ser interrompida passando uma signal opção e abortando o AbortController relacionado, enquanto for await...of pode ser interrompida com break ou return. Em qualquer dos casos, o riacho será destruído.

Este método difere de ouvir o 'data' evento, pois utiliza o readable evento na maquinaria subjacente e pode limitar o número de chamadas fn simultâneas.

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

Parâmetros

fn

(data: any, options?: Abortable) => void | Promise<void>

uma função para chamar cada pedaço do fluxo. Assíncrono ou não.

options

Pick<ReadableOperatorOptions, "signal" | "concurrency">

Devoluções

Promise<void>

uma promessa para quando a transmissão terminar.

from(Iterable<any> | AsyncIterable<any>, ReadableOptions<Readable>)

Um método utilitário para criar Fluxos Legíveis a partir de iteradores.

static function from(iterable: Iterable<any> | AsyncIterable<any>, options?: ReadableOptions<Readable>): Readable

Parâmetros

iterable

Iterable<any> | AsyncIterable<any>

Objeto a implementar o Symbol.asyncIterator protocolo iterável Symbol.iterator . Emite um evento de 'erro' se for transmitido um valor nulo.

options

ReadableOptions<Readable>

Opções fornecidas a new stream.Readable([options]). Por defeito, Readable.from() definirá options.objectMode para true, a menos que isto seja explicitamente excluído definindo options.objectMode para false.

Devoluções

Readable

fromWeb(ReadableStream<any>, Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">)

Um método utilitário para criar um Readable a partir de uma web ReadableStream.

static function fromWeb(readableStream: ReadableStream<any>, options?: Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">): Readable

Parâmetros

readableStream

ReadableStream<any>

options

Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">

Devoluções

Readable

isDisturbed(ReadableStream<any> | ReadableStream)

Devolve se a transmissão foi lida ou cancelada.

static function isDisturbed(stream: ReadableStream<any> | ReadableStream): boolean

Parâmetros

stream

ReadableStream<any> | ReadableStream

Devoluções

boolean

isPaused()

O readable.isPaused() método devolve o estado operacional atual do Readable. Isto é usado principalmente pelo mecanismo que sustenta o readable.pipe() método. Na maioria dos casos típicos, não haverá razão para usar este método diretamente.

const readable = new stream.Readable();

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

function isPaused(): boolean

Devoluções

boolean

iterator(ReadableIteratorOptions)

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

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

Parâmetros

options

ReadableIteratorOptions

Devoluções

AsyncIterator<any, undefined, any>

listenerCount(string | symbol, (args: any[]) => void) 

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluções

number

listenerCount<E>(E, (args: ReadableEventMap[E]) => void) 

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

Parâmetros

eventName

E

listener

(args: ReadableEventMap[E]) => void

Devoluções

number

listeners(string | symbol) 

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

Parâmetros

eventName

string | symbol

Devoluções

(args: any[]) => void[]

listeners<E>(E) 

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

Parâmetros

eventName

E

Devoluções

(args: ReadableEventMap[E]) => void[]

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

Este método permite mapear sobre o riacho. A função fn será chamada para cada bloco do 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

fn

(data: any, options?: Abortable) => any

uma função para mapear cada bloco do fluxo. Assíncrono ou não.

options

ReadableOperatorOptions

Devoluções

Readable

um fluxo mapeado com a função fn.

off(string | symbol, (args: any[]) => void) 

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluções

Readable

off<E>(E, (args: ReadableEventMap[E]) => void) 

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

Parâmetros

eventName

E

listener

(args: ReadableEventMap[E]) => void

Devoluções

Readable

on(string | symbol, (args: any[]) => void) 

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluções

Readable

on<E>(E, (args: ReadableEventMap[E]) => void) 

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

Parâmetros

eventName

E

listener

(args: ReadableEventMap[E]) => void

Devoluções

Readable

once(string | symbol, (args: any[]) => void) 

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluções

Readable

once<E>(E, (args: ReadableEventMap[E]) => void) 

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

Parâmetros

eventName

E

listener

(args: ReadableEventMap[E]) => void

Devoluções

Readable

pause()

O readable.pause() método fará com que um fluxo em modo de fluxo pare de emitir 'data' eventos, saindo do modo de fluxo. Quaisquer dados que fiquem disponíveis permanecerão 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(): Readable

Devoluções

Readable

prependListener(string | symbol, (args: any[]) => void) 

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluções

Readable

prependListener<E>(E, (args: ReadableEventMap[E]) => void) 

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

Parâmetros

eventName

E

listener

(args: ReadableEventMap[E]) => void

Devoluções

Readable

prependOnceListener(string | symbol, (args: any[]) => void) 

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluções

Readable

prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void) 

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

Parâmetros

eventName

E

listener

(args: ReadableEventMap[E]) => void

Devoluções

Readable

push(any, BufferEncoding) 

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

Parâmetros

chunk

any

encoding

BufferEncoding

Devoluções

boolean

rawListeners(string | symbol) 

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

Parâmetros

eventName

string | symbol

Devoluções

(args: any[]) => void[]

rawListeners<E>(E) 

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

Parâmetros

eventName

E

Devoluções

(args: ReadableEventMap[E]) => void[]

read(number)

O readable.read() método lê dados do buffer interno e devolve-os. Se não houver dados disponíveis para leitura, null é devolvido. Por defeito, os dados são devolvidos como objeto Buffer , a menos que uma codificação tenha sido especificada usando o readable.setEncoding() método ou que o fluxo esteja a operar em modo objeto.

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

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 que operam 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 para readable.read() devolve um bloco de dados, ou null. Os chunks não são concatenados. É necessário um while ciclo para consumir todos os dados atualmente no buffer. Ao ler, um ficheiro .read() grande pode devolver null, tendo consumido todo o conteúdo armazenado até agora, mas ainda há mais dados por vir, ainda não armazenados. Neste 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 disponíveis.

Portanto, para ler todo o conteúdo de um ficheiro a partir de um readable, é necessário recolher 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 em modo objeto devolverá sempre um único item de uma chamada para readable.read(size), independentemente do valor do size argumento.

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

A chamada de leitura após o 'end' evento ter sido emitido retornará null. Não será apresentado nenhum erro de execução.

function read(size?: number): any

Parâmetros

size

number

Argumento opcional para especificar quantos dados ler.

Devoluções

any

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

Este método chama fn em cada bloco do fluxo por ordem, passando-lhe o resultado do cálculo no elemento anterior. Devolve uma promessa do valor final da redução.

Se não for fornecido valor inicial , o primeiro bloco do fluxo é usado como valor inicial. Se o fluxo estiver vazio, a promessa é rejeitada com a TypeErrorERR_INVALID_ARGS propriedade de código.

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

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

Parâmetros

fn

(previous: any, data: any, options?: Abortable) => T

uma função redutora para chamar todos os blocos do fluxo. Assíncrono ou não.

Devoluções

Promise<T>

uma promessa do valor final da redução.

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

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

Parâmetros

fn

(previous: T, data: any, options?: Abortable) => T

initial

T

options

Abortable

Devoluções

Promise<T>

removeAllListeners(string | symbol) 

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

Parâmetros

eventName

string | symbol

Devoluções

Readable

removeAllListeners<E>(E) 

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

Parâmetros

eventName

E

Devoluções

Readable

removeListener(string | symbol, (args: any[]) => void) 

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

Parâmetros

eventName

string | symbol

listener

(args: any[]) => void

Devoluções

Readable

removeListener<E>(E, (args: ReadableEventMap[E]) => void) 

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

Parâmetros

eventName

E

listener

(args: ReadableEventMap[E]) => void

Devoluções

Readable

resume()

O readable.resume() método faz com que um fluxo explicitamente Readable pausado retome a 'data' emissão de eventos, mudando o fluxo para 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(): Readable

Devoluções

Readable

setEncoding(BufferEncoding)

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

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

O Readable fluxo lida corretamente com caracteres multibyte entregues através do fluxo que, de outra forma, seriam decodificados incorretamente 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): Readable

Parâmetros

encoding

BufferEncoding

A codificação a usar.

Devoluções

Readable

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

Este método é semelhante a Array.prototype.some e chama fn em cada bloco do fluxo até que o valor de retorno aguardado seja true (ou qualquer valor truthy). Uma vez que uma chamada fn num valor de retorno de chunk awaited é verdadeira, o fluxo é destruído e a promessa é cumprida com true. Se nenhum dos fn calls nos chunks devolver um valor truthy, a promessa é cumprida com false.

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

Parâmetros

fn

(data: any, options?: Abortable) => boolean | Promise<boolean>

uma função para chamar cada pedaço do fluxo. Assíncrono ou não.

options

Pick<ReadableOperatorOptions, "signal" | "concurrency">

Devoluções

Promise<boolean>

Uma promessa que avalia se trueo FN devolveu um valor truthy para pelo menos um dos chunks.

take(number, Abortable)

Este método devolve um novo fluxo com os primeiros blocos limite .

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

Parâmetros

limit

number

O número de blocos a retirar do legível.

options

Abortable

Devoluções

Readable

um stream com blocos de limite ocupados.

toArray(Abortable)

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

Como este método lê todo o fluxo na memória, anula os benefícios dos fluxos. Destina-se à interoperabilidade e conveniência, não a principal forma de consumir streams.

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

Parâmetros

options

Abortable

Devoluções

Promise<any[]>

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

toWeb(ReadableStream, ReadableToWebOptions)

Um método utilitário para criar uma teia ReadableStream a partir de um Readable.

static function toWeb(streamReadable: ReadableStream, options?: ReadableToWebOptions): ReadableStream<any>

Parâmetros

streamReadable

ReadableStream

options

ReadableToWebOptions

Devoluções

ReadableStream<any>

unpipe(WritableStream)

O readable.unpipe() método destaca um Writable jato previamente ligado 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 não estiver configurado nenhum tubo 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): Readable

Parâmetros

destination

WritableStream

Fluxo específico opcional para despipear

Devoluções

Readable

unshift(any, BufferEncoding)

Passar chunk como null sinaliza o fim do fluxo (EOF) e comporta-se da mesma forma que readable.push(null), após o que não podem ser escritos mais dados. O sinal EOF é colocado no final do buffer e quaisquer dados armazenados em buffer continuam a ser eliminados.

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

O stream.unshift(chunk) método não pode ser chamado depois de o 'end' evento ter sido emitido, caso contrário será lançado um erro em tempo de execução.

Os programadores que usam stream.unshift() frequentemente devem considerar mudar para o uso de um Transform stream em vez disso. Consulte a API for stream implementers secçã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, stream.unshift(chunk) não termina o processo de leitura ao reiniciar o estado interno de leitura do fluxo. Isto pode causar resultados inesperados se readable.unshift() for chamado durante uma leitura (ou seja, a partir de uma implementação _read num fluxo personalizado). Seguir a chamada readable.unshift() com um push imediato irá reiniciar o estado de leitura corretamente, no entanto, é melhor simplesmente evitar ligar readable.unshift() durante o processo de leitura.

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

Parâmetros

chunk

any

Pedaço de dados para deslocar para a fila de leitura. Para fluxos que não operam em modo objeto, chunk deve ser uma {string}, {Buffer}, {TypedArray}, {DataView} ou null. Para fluxos em modo objeto, chunk pode ser qualquer valor JavaScript.

encoding

BufferEncoding

Codificação de blocos de cadeia. Deve ser uma codificação válida Buffer , como 'utf8' ou 'ascii'.

wrap(ReadableStream)

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

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

Raramente será necessário utilizá-lo readable.wrap() , mas o método foi disponibilizado como uma conveniência para interagir com aplicações e bibliotecas Node.js mais antigas.

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): Readable

Parâmetros

stream

ReadableStream

Um fluxo legível de "estilo antigo"

Devoluções

Readable

[asyncIterator]() 

function [asyncIterator](): AsyncIterator<any, undefined, any>

Devoluções

AsyncIterator<any, undefined, any>

AsyncIterator para consumir totalmente o fluxo.

Detalhes do Método Herdado

eventNames()

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)[]

Devoluções

(string | symbol)[]

Herdado de Stream.eventNames

getMaxListeners()

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

function getMaxListeners(): number

Devoluções

number

Herdado de Stream.getMaxListeners

pipe<T>(T, PipeOptions) 

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

Parâmetros

destination

T

options

PipeOptions

Devoluções

T

Herdado de Stream.pipe

setMaxListeners(number)

Por padrãoEventEmitters imprimirá um aviso se mais de 10 ouvintes forem adicionados para um evento específico. Este é um padrão útil que ajuda a encontrar vazamentos de memória. O método emitter.setMaxListeners() permite que o limite seja modificado para esta instância 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): Readable

Parâmetros

n

number

Devoluções

Readable

Herdado de Stream.setMaxOuvintes

[captureRejectionSymbol](Error, string | symbol, any[])

O Symbol.for('nodejs.rejection') método é chamado caso ocorra uma rejeição de promessa ao emitir um evento e captureRejections está ativado no emissor. É possível usar events.captureRejectionSymbol em vez 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

error

Error

event

string | symbol

args

any[]

Herdado de Stream.__@captureRejectionSymbol@175