Readable class

Paquete:
@azure/storage-common
Extends

Stream

Constructores

Readable(ReadableOptions<Readable>)

Propiedades

closed

Es true después 'close' de que se ha emitido.
destroyed

Es true después readable.destroy() de que se haya llamado.
errored

Devuelve error si el flujo ha sido destruido con un error.
readable

Es true si es seguro llamar a read, lo que significa que el flujo no ha sido destruido ni emitido 'error' o 'end'.
readableAborted

Devuelve si el flujo fue destruido o cometió un error antes de emitir 'end'.
readableDidRead

Devuelve si 'data' ha sido emitido.
readableEncoding

Getter para la propiedad encoding de un arroyo dado Readable . La encoding propiedad puede establecerse usando el método setEncoding .
readableEnded

Se convierte true en cuando 'end' se emite el evento.
readableFlowing

Esta propiedad refleja el estado actual de un Readable arroyo tal como se describe en la sección de los Tres estados .
readableHighWaterMark

Devuelve el valor de highWaterMark pasado al crear este Readable.
readableLength

Esta propiedad contiene el número de bytes (u objetos) en la cola listos para ser leídos. El valor proporciona datos de introspección sobre el estado de los highWaterMark.
readableObjectMode

Getter para la propiedad objectMode de un arroyo dado Readable .

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) equivale a stream.compose(readable, s).

Este método también permite proporcionar un AbortSignal , que destruirá el flujo compuesto cuando se aborte.

Consulte stream.compose(...streams) para obtener más información.
destroy(Error)

Destruye la secuencia. Opcionalmente emitir un 'error' evento y emitir un 'close' evento (a menos que emitClose esté configurado en false). Tras esta llamada, el flujo legible liberará cualquier recurso interno y las llamadas push() posteriores serán ignoradas.

Una vez destroy() llamada, cualquier llamada adicional será un no-op y no se emitirán más errores excepto desde _destroy() .'error'

Los implementadores no deben anular este método, sino implementar readable._destroy().
drop(number, Abortable)

Este método devuelve un nuevo flujo con los primeros bloques límite eliminados desde el inicio.
emit(string | symbol, any[])
emit<E>(E, ReadableEventMap[E])
every((data: any, options?: Abortable) => boolean | Promise<boolean>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Este método es similar a Array.prototype.every y llama a fn en cada chunk del flujo para comprobar si todos los valores de retorno esperados son un valor truthy para fn. Una vez que una llamada fn sobre un valor de retorno ed de chunk awaites falsa, el flujo se destruye y la promesa se cumple con false. Si todas las llamadas de fn en los chunks devolven un valor truthy, la promesa se cumple con true.
filter((data: any, options?: Abortable) => boolean | Promise<boolean>, ReadableOperatorOptions)

Este método permite filtrar el chorro. Para cada chunk en el flujo se llamará la función fn y si devuelve un valor truthy, el chunk se pasará al flujo resultante. Si la función fn devuelve una promesa, esa promesa 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 es similar a Array.prototype.find y llama a fn en cada chunk del flujo para encontrar un chunk con un valor truthy para fn. Una vez que el valor de retorno esperado de una llamada de fn es truthy, el flujo se destruye y la promesa se cumple con un valor por el que fn devolvió un valor truthy. Si todas las llamadas fn en los chunks devolven un valor falso, la promesa se cumple con undefined.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Este método devuelve un nuevo flujo aplicando la callback dada a cada fragmento del flujo y luego aplanando el resultado.

Es posible devolver un flujo u otro iterable iterable o asíncrono desde fn y los flujos resultantes se fusionarán (aplanarán) en el flujo devuelto.
forEach((data: any, options?: Abortable) => void | Promise<void>, Pick<ReadableOperatorOptions, "signal" | "concurrency">)

Este método permite iterar un flujo. Para cada fragmento en el flujo se llamará la función fn . Si la función fn devuelve una promesa, esa promesa será awaited.

Este método se diferencia de for await...of los bucles en que puede procesar chunks simultáneamente opcionalmente. Además, una forEach iteración solo puede detenerse si se ha pasado una signal opción y se aborta el AbortController correspondiente, mientras que for await...of puede detenerse con break o return. En cualquier caso, el arroyo será destruido.

Este método es diferente de escuchar el 'data' evento en que utiliza el readable evento en la maquinaria subyacente y puede limitar el número de llamadas fn concurrentes.
from(Iterable<any> | AsyncIterable<any>, ReadableOptions<Readable>)

Un método de utilidad para crear flujos legibles a partir de iteradores.
fromWeb(ReadableStream<any>, Pick<ReadableOptions<Readable>, "encoding" | "highWaterMark" | "objectMode" | "signal">)

Un método de utilidad para crear un Readable a partir de una web ReadableStream.
isDisturbed(ReadableStream<any> | ReadableStream)

Retorna tanto si la transmisión ha sido leída como cancelada.
isPaused()

El readable.isPaused() método devuelve el estado operativo actual de la Readable. Esto se utiliza principalmente por el mecanismo que subyace al readable.pipe() método. En la mayoría de los casos típicos, no habrá razón para usar este método directamente.

const readable = new stream.Readable();

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

El iterador creado por este método da a los usuarios la opción de cancelar la destrucción del flujo si el for await...of bucle sale por return, break, o throw, o si el iterador debe destruir el flujo si emitió un error durante la iteración.
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 el arroyo. La función fn se llamará para cada fragmento del flujo. Si la función fn devuelve una promesa, esa promesa será awaited antes de ser pasada al flujo 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()

El readable.pause() método hará que un flujo en modo flujo deje de emitir 'data' eventos, cambiando de modo flujo. Cualquier dato que esté disponible permanecerá en el 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);
});

El readable.pause() método no tiene efecto si hay un 'readable' oyente 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)

El readable.read() método lee los datos del búfer interno y los devuelve. Si no hay datos disponibles para leer, null se devuelve. Por defecto, los datos se devuelven como objeto Buffer a menos que se haya especificado una codificación usando el readable.setEncoding() método o que el flujo esté funcionando en modo objeto.

El argumento opcional size especifica un número específico de bytes a leer. Si size no hay bytes disponibles para ser leídos, null se devolverán a menos que el flujo haya terminado, en cuyo caso se devolverán todos los datos restantes en el búfer interno.

Si el size argumento no se especifica, todos los datos contenidos en el búfer interno serán devueltos.

El size argumento debe ser menor o igual a 1 GiB.

El readable.read() método solo debe llamarse en Readable flujos que operan en modo pausa. En modo fluido, readable.read() se llama automáticamente hasta que el buffer interno se vacía completamente.

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 llamada a readable.read() devuelve un fragmento de datos, o null. Los chunks no están concatenados. Es necesario un while bucle para consumir todos los datos que actualmente están en el búfer. Al leer un archivo .read() grande puede devolver null, habiendo consumido todo el contenido almacenado en búfer hasta ahora, pero aún queda más datos que aún no están almacenados en búfer. En este caso, se emitirá un nuevo 'readable' evento cuando haya más datos en el búfer. Finalmente, el 'end' evento se emitirá cuando no haya más datos disponibles.

Por lo tanto, para leer todo el contenido de un archivo desde un readable, es necesario recopilar fragmentos a través de múltiples 'readable' eventos:

const chunks = [];

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

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

Un Readable flujo en modo objeto siempre devolverá un solo elemento de una llamada a readable.read(size), independientemente del valor del size argumento.

Si el readable.read() método devuelve un fragmento de datos, también se emitirá un 'data' evento.

Llamar leer después de que el 'end' evento haya sido emitido volverá null. No se generará ningún error en tiempo de ejecución.
reduce<T>((previous: any, data: any, options?: Abortable) => T)

Este método llama a fn en cada fragmento del flujo en orden, pasándole el resultado del cálculo sobre el elemento anterior. Devuelve una promesa por el valor final de la reducción.

Si no se proporciona un valor inicial , se utiliza el primer fragmento del flujo como valor inicial. Si el flujo está vacío, la promesa se rechaza con una TypeError con la ERR_INVALID_ARGS propiedad de código.

La función reductora itera el flujo elemento por elemento, lo que significa que no existe un parámetro de concurrencia ni paralelismo. Para realizar una reducción simultáneamente, puedes extraer la función asíncrona al 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()

El readable.resume() método provoca que una corriente explícitamente Readable pausada reanude la 'data' emisión de eventos, cambiando la corriente a modo de flujo.

El readable.resume() método puede usarse para consumir completamente los datos de un flujo sin procesar realmente ninguno de esos datos:

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

El readable.resume() método no tiene efecto si hay un 'readable' oyente de eventos.
setEncoding(BufferEncoding)

El readable.setEncoding() método establece la codificación de caracteres para los datos leídos del Readable flujo.

Por defecto, no se asigna codificación y los datos del flujo se devolverán como Buffer objetos. Establecer una codificación hace que los datos del flujo se devuelvan como cadenas de la codificación especificada en lugar de como Buffer objetos. Por ejemplo, al llamar readable.setEncoding('utf8') , los datos de salida se interpretan como datos UTF-8 y se pasan como cadenas. Llamar readable.setEncoding('hex') hará que los datos se codifiquen en formato de cadena hexadecimal.

El Readable flujo gestionará correctamente los caracteres de varios bytes entregados a través del flujo que de otro modo se decodificarían incorrectamente si simplemente se extraen del flujo 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 es similar a Array.prototype.some y llama a fn en cada fragmento del flujo hasta que el valor de retorno esperado es true (o cualquier valor truthy). Una vez que una llamada fn sobre un valor de retorno de chunk awaited es veracífica, el flujo se destruye y la promesa se cumple con true. Si ninguna de las llamadas de fn en los chunks devuelve un valor truthy, la promesa se cumple con false.
take(number, Abortable)

Este método devuelve un nuevo flujo con los primeros bloques límite .
toArray(Abortable)

Este método permite obtener fácilmente el contenido de un stream.

Como este método lee todo el flujo en la memoria, anula los beneficios de los flujos. Está pensado para la interoperabilidad y la comodidad, no como la forma principal de consumir streams.
toWeb(ReadableStream, ReadableToWebOptions)

Un método de utilidad para crear una web ReadableStream a partir de un Readablearchivo .
unpipe(WritableStream)

El readable.unpipe() método desprende un Writable arroyo previamente conectado usando el método de la tubería .

Si no se especifica el destination , entonces todas las tuberías se desacoplan.

Si se especifica destination pero no hay tubería configurada para ello, entonces el método no hace 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)

Pasar chunk como null señala el final del flujo (EOF) y se comporta igual que readable.push(null), tras lo cual no se pueden escribir más datos. La señal EOF se coloca al final del búfer y cualquier dato almacenado en búfer se eliminará.

El readable.unshift() método envía un fragmento de datos de vuelta al búfer interno. Esto es útil en ciertas situaciones en las que un flujo está siendo consumido por código que necesita "desconsumir" cierta cantidad de datos que ha extraído optimistamente de la fuente, para que los datos puedan ser transmitidos a otra parte.

El stream.unshift(chunk) método no puede llamarse después de que el 'end' evento haya sido emitido o se generará un error en tiempo de ejecución.

Los desarrolladores que usen stream.unshift() a menudo deberían considerar cambiar a un Transform stream en su lugar. Consulta la API for stream implementers sección para más información.

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

A diferencia del push, stream.unshift(chunk) no termina el proceso de lectura reiniciando el estado interno de lectura del flujo. Esto puede causar resultados inesperados si readable.unshift() se llama durante una lectura (es decir, desde dentro de una implementación _read en un flujo personalizado). Seguir la llamada con readable.unshift() un empuje inmediato reiniciará el estado de lectura adecuadamente, sin embargo, es mejor evitar llamar readable.unshift() mientras realizas una lectura.
wrap(ReadableStream)

Antes de Node.js 0.10, los flujos no implementaban la API completa node:stream del módulo tal como está definida actualmente. (Véase Compatibility para más información.)

Cuando se utiliza una biblioteca de Node.js antigua que emite 'data' eventos y tiene un método de pausa que es solo asesor, el readable.wrap() método puede usarse para crear un Readable flujo que utilice el flujo antiguo como fuente de datos.

Rara vez será necesario usarlo readable.wrap() , pero el método se ha proporcionado como una comodidad para interactuar con aplicaciones y bibliotecas Node.js antiguas.

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 heredados

eventNames()

Devuelve una matriz que enumera los eventos para los que el emisor ha registrado agentes de escucha.

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

Devuelve el valor máximo actual del agente de escucha para el EventEmitter que se establece mediante emitter.setMaxListeners(n) o los valores predeterminados en events.defaultMaxListeners.
pipe<T>(T, PipeOptions)
setMaxListeners(number)

De forma predeterminada, EventEmitters imprimirán una advertencia si se agregan más de 10 agentes de escucha para un evento determinado. Este es un valor predeterminado útil que ayuda a encontrar fugas de memoria. El método emitter.setMaxListeners() permite modificar el límite para esta instancia de EventEmitter específica. El valor se puede establecer en Infinity (o 0) para indicar un número ilimitado de agentes de escucha.

Devuelve una referencia al EventEmitter, para que las llamadas se puedan encadenar.
[captureRejectionSymbol](Error, string | symbol, any[])

El Symbol.for('nodejs.rejection') método se llama en caso de que ocurra un rechazo de promesa al emitir un evento y captureRejections está habilitado en el emisor. Es posible usarlo events.captureRejectionSymbol en 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.
  }
}

Detalles del constructor

Readable(ReadableOptions<Readable>) 

new Readable(options?: ReadableOptions<Readable>)

Parámetros

options

ReadableOptions<Readable>

Detalles de las propiedades

closed

Es true después 'close' de que se ha emitido.

closed: boolean

Valor de propiedad

boolean

destroyed

Es true después readable.destroy() de que se haya llamado.

destroyed: boolean

Valor de propiedad

boolean

errored

Devuelve error si el flujo ha sido destruido con un error.

errored: null | Error

Valor de propiedad

null | Error

readable

Es true si es seguro llamar a read, lo que significa que el flujo no ha sido destruido ni emitido 'error' o 'end'.

readable: boolean

Valor de propiedad

boolean

readableAborted

Devuelve si el flujo fue destruido o cometió un error antes de emitir 'end'.

readableAborted: boolean

Valor de propiedad

boolean

readableDidRead

Devuelve si 'data' ha sido emitido.

readableDidRead: boolean

Valor de propiedad

boolean

readableEncoding

Getter para la propiedad encoding de un arroyo dado Readable . La encoding propiedad puede establecerse usando el método setEncoding .

readableEncoding: null | BufferEncoding

Valor de propiedad

null | BufferEncoding

readableEnded

Se convierte true en cuando 'end' se emite el evento.

readableEnded: boolean

Valor de propiedad

boolean

readableFlowing

Esta propiedad refleja el estado actual de un Readable arroyo tal como se describe en la sección de los Tres estados .

readableFlowing: null | boolean

Valor de propiedad

null | boolean

readableHighWaterMark

Devuelve el valor de highWaterMark pasado al crear este Readable.

readableHighWaterMark: number

Valor de propiedad

number

readableLength

Esta propiedad contiene el número de bytes (u objetos) en la cola listos para ser leídos. El valor proporciona datos de introspección sobre el estado de los highWaterMark.

readableLength: number

Valor de propiedad

number

readableObjectMode

Getter para la propiedad objectMode de un arroyo dado Readable .

readableObjectMode: boolean

Valor de propiedad

boolean

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

Devoluciones

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

Devoluciones

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) equivale a stream.compose(readable, s).

Este método también permite proporcionar un AbortSignal , que destruirá el flujo compuesto cuando se aborte.

Consulte stream.compose(...streams) para obtener más información.

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

Devoluciones

Duplex

un arroyo compuesto por el arroyo stream.

destroy(Error)

Destruye la secuencia. Opcionalmente emitir un 'error' evento y emitir un 'close' evento (a menos que emitClose esté configurado en false). Tras esta llamada, el flujo legible liberará cualquier recurso interno y las llamadas push() posteriores serán ignoradas.

Una vez destroy() llamada, cualquier llamada adicional será un no-op y no se emitirán más errores excepto desde _destroy() .'error'

Los implementadores no deben anular este método, sino implementar readable._destroy().

function destroy(error?: Error): Readable

Parámetros

error

Error

Error que se transmitirá como carga útil en 'error' caso de

Devoluciones

Readable

drop(number, Abortable)

Este método devuelve un nuevo flujo con los primeros bloques límite eliminados desde el inicio.

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

Parámetros

limit

number

el número de fragmentos que se pueden eliminar de lo legible.

options

Abortable

Devoluciones

Readable

un stream con bloques límite que se cayó desde el principio.

emit(string | symbol, any[]) 

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

Parámetros

eventName

string | symbol

args

any[]

Devoluciones

boolean

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

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

Parámetros

eventName

E

args

ReadableEventMap[E]

Devoluciones

boolean

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

Este método es similar a Array.prototype.every y llama a fn en cada chunk del flujo para comprobar si todos los valores de retorno esperados son un valor truthy para fn. Una vez que una llamada fn sobre un valor de retorno ed de chunk awaites falsa, el flujo se destruye y la promesa se cumple con false. Si todas las llamadas de fn en los chunks devolven un valor truthy, la promesa se cumple con 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>

una función para llamar a cada fragmento del flujo. Asincrónico o no.

options

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

Devoluciones

Promise<boolean>

Una promesa que evalúa si trueFN devolvió un valor de verdad para cada uno de los chunks.

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

Este método permite filtrar el chorro. Para cada chunk en el flujo se llamará la función fn y si devuelve un valor truthy, el chunk se pasará al flujo resultante. Si la función fn devuelve una promesa, esa promesa 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>

una función para filtrar fragmentos del flujo. Asincrónico o no.

options

ReadableOperatorOptions

Devoluciones

Readable

un flujo filtrado con el 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">

Devoluciones

Promise<any>

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

Este método es similar a Array.prototype.find y llama a fn en cada chunk del flujo para encontrar un chunk con un valor truthy para fn. Una vez que el valor de retorno esperado de una llamada de fn es truthy, el flujo se destruye y la promesa se cumple con un valor por el que fn devolvió un valor truthy. Si todas las llamadas fn en los chunks devolven un valor falso, la promesa se cumple con 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

una función para llamar a cada fragmento del flujo. Asincrónico o no.

options

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

Devoluciones

Promise<undefined | T>

una promesa que se evalúa al primer fragmento para el que FN evaluó con un valor truthy, o undefined si no se encontró ningún elemento.

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

Este método devuelve un nuevo flujo aplicando la callback dada a cada fragmento del flujo y luego aplanando el resultado.

Es posible devolver un flujo u otro iterable iterable o asíncrono desde fn y los flujos resultantes se fusionarán (aplanarán) en el flujo devuelto.

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

Parámetros

fn

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

una función para mapear cada fragmento del flujo. Puede que sea asincrónico. Puede ser un arroyo o generador.

options

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

Devoluciones

Readable

un flujo mapeado plano con la función fn.

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

Este método permite iterar un flujo. Para cada fragmento en el flujo se llamará la función fn . Si la función fn devuelve una promesa, esa promesa será awaited.

Este método se diferencia de for await...of los bucles en que puede procesar chunks simultáneamente opcionalmente. Además, una forEach iteración solo puede detenerse si se ha pasado una signal opción y se aborta el AbortController correspondiente, mientras que for await...of puede detenerse con break o return. En cualquier caso, el arroyo será destruido.

Este método es diferente de escuchar el 'data' evento en que utiliza el readable evento en la maquinaria subyacente y puede limitar el número de llamadas fn concurrentes.

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>

una función para llamar a cada fragmento del flujo. Asincrónico o no.

options

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

Devoluciones

Promise<void>

una promesa para cuando el stream termine.

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

Un método de utilidad para crear flujos legibles a partir de iteradores.

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

Parámetros

iterable

Iterable<any> | AsyncIterable<any>

Objeto que implementa el Symbol.asyncIterator protocolo o Symbol.iterator iterable. Emite un evento de 'error' si se pasa un valor nulo.

options

ReadableOptions<Readable>

Opciones proporcionadas a new stream.Readable([options]). Por defecto, Readable.from() se establecerá options.objectMode en true, a menos que esto se opte explícitamente por no ser asignado options.objectMode a false.

Devoluciones

Readable

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

Un método de utilidad para crear un Readable a partir de una 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">

Devoluciones

Readable

isDisturbed(ReadableStream<any> | ReadableStream)

Retorna tanto si la transmisión ha sido leída como cancelada.

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

Parámetros

stream

ReadableStream<any> | ReadableStream

Devoluciones

boolean

isPaused()

El readable.isPaused() método devuelve el estado operativo actual de la Readable. Esto se utiliza principalmente por el mecanismo que subyace al readable.pipe() método. En la mayoría de los casos típicos, no habrá razón para usar este método directamente.

const readable = new stream.Readable();

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

function isPaused(): boolean

Devoluciones

boolean

iterator(ReadableIteratorOptions)

El iterador creado por este método da a los usuarios la opción de cancelar la destrucción del flujo si el for await...of bucle sale por return, break, o throw, o si el iterador debe destruir el flujo si emitió un error durante la iteración.

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

Parámetros

options

ReadableIteratorOptions

Devoluciones

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

Devoluciones

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

Devoluciones

number

listeners(string | symbol) 

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

Parámetros

eventName

string | symbol

Devoluciones

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

listeners<E>(E) 

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

Parámetros

eventName

E

Devoluciones

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

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

Este método permite mapear sobre el arroyo. La función fn se llamará para cada fragmento del flujo. Si la función fn devuelve una promesa, esa promesa será awaited antes de ser pasada al flujo de resultados.

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

Parámetros

fn

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

una función para mapear cada fragmento del flujo. Asincrónico o no.

options

ReadableOperatorOptions

Devoluciones

Readable

un flujo mapeado con la función 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

Devoluciones

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

Devoluciones

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

Devoluciones

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

Devoluciones

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

Devoluciones

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

Devoluciones

Readable

pause()

El readable.pause() método hará que un flujo en modo flujo deje de emitir 'data' eventos, cambiando de modo flujo. Cualquier dato que esté disponible permanecerá en el 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);
});

El readable.pause() método no tiene efecto si hay un 'readable' oyente de eventos.

function pause(): Readable

Devoluciones

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

Devoluciones

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

Devoluciones

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

Devoluciones

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

Devoluciones

Readable

push(any, BufferEncoding) 

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

Parámetros

chunk

any

encoding

BufferEncoding

Devoluciones

boolean

rawListeners(string | symbol) 

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

Parámetros

eventName

string | symbol

Devoluciones

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

rawListeners<E>(E) 

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

Parámetros

eventName

E

Devoluciones

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

read(number)

El readable.read() método lee los datos del búfer interno y los devuelve. Si no hay datos disponibles para leer, null se devuelve. Por defecto, los datos se devuelven como objeto Buffer a menos que se haya especificado una codificación usando el readable.setEncoding() método o que el flujo esté funcionando en modo objeto.

El argumento opcional size especifica un número específico de bytes a leer. Si size no hay bytes disponibles para ser leídos, null se devolverán a menos que el flujo haya terminado, en cuyo caso se devolverán todos los datos restantes en el búfer interno.

Si el size argumento no se especifica, todos los datos contenidos en el búfer interno serán devueltos.

El size argumento debe ser menor o igual a 1 GiB.

El readable.read() método solo debe llamarse en Readable flujos que operan en modo pausa. En modo fluido, readable.read() se llama automáticamente hasta que el buffer interno se vacía completamente.

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 llamada a readable.read() devuelve un fragmento de datos, o null. Los chunks no están concatenados. Es necesario un while bucle para consumir todos los datos que actualmente están en el búfer. Al leer un archivo .read() grande puede devolver null, habiendo consumido todo el contenido almacenado en búfer hasta ahora, pero aún queda más datos que aún no están almacenados en búfer. En este caso, se emitirá un nuevo 'readable' evento cuando haya más datos en el búfer. Finalmente, el 'end' evento se emitirá cuando no haya más datos disponibles.

Por lo tanto, para leer todo el contenido de un archivo desde un readable, es necesario recopilar fragmentos a través de múltiples 'readable' eventos:

const chunks = [];

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

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

Un Readable flujo en modo objeto siempre devolverá un solo elemento de una llamada a readable.read(size), independientemente del valor del size argumento.

Si el readable.read() método devuelve un fragmento de datos, también se emitirá un 'data' evento.

Llamar leer después de que el 'end' evento haya sido emitido volverá null. No se generará ningún error en tiempo de ejecución.

function read(size?: number): any

Parámetros

size

number

Argumento opcional para especificar cuántos datos leer.

Devoluciones

any

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

Este método llama a fn en cada fragmento del flujo en orden, pasándole el resultado del cálculo sobre el elemento anterior. Devuelve una promesa por el valor final de la reducción.

Si no se proporciona un valor inicial , se utiliza el primer fragmento del flujo como valor inicial. Si el flujo está vacío, la promesa se rechaza con una TypeError con la ERR_INVALID_ARGS propiedad de código.

La función reductora itera el flujo elemento por elemento, lo que significa que no existe un parámetro de concurrencia ni paralelismo. Para realizar una reducción simultáneamente, puedes extraer la función asíncrona al 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

una función reductora para llamar a cada fragmento del flujo. Asincrónico o no.

Devoluciones

Promise<T>

una promesa del valor final de la reducción.

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

Devoluciones

Promise<T>

removeAllListeners(string | symbol) 

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

Parámetros

eventName

string | symbol

Devoluciones

Readable

removeAllListeners<E>(E) 

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

Parámetros

eventName

E

Devoluciones

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

Devoluciones

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

Devoluciones

Readable

resume()

El readable.resume() método provoca que una corriente explícitamente Readable pausada reanude la 'data' emisión de eventos, cambiando la corriente a modo de flujo.

El readable.resume() método puede usarse para consumir completamente los datos de un flujo sin procesar realmente ninguno de esos datos:

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

El readable.resume() método no tiene efecto si hay un 'readable' oyente de eventos.

function resume(): Readable

Devoluciones

Readable

setEncoding(BufferEncoding)

El readable.setEncoding() método establece la codificación de caracteres para los datos leídos del Readable flujo.

Por defecto, no se asigna codificación y los datos del flujo se devolverán como Buffer objetos. Establecer una codificación hace que los datos del flujo se devuelvan como cadenas de la codificación especificada en lugar de como Buffer objetos. Por ejemplo, al llamar readable.setEncoding('utf8') , los datos de salida se interpretan como datos UTF-8 y se pasan como cadenas. Llamar readable.setEncoding('hex') hará que los datos se codifiquen en formato de cadena hexadecimal.

El Readable flujo gestionará correctamente los caracteres de varios bytes entregados a través del flujo que de otro modo se decodificarían incorrectamente si simplemente se extraen del flujo 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

Codificación que se va a usar.

Devoluciones

Readable

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

Este método es similar a Array.prototype.some y llama a fn en cada fragmento del flujo hasta que el valor de retorno esperado es true (o cualquier valor truthy). Una vez que una llamada fn sobre un valor de retorno de chunk awaited es veracífica, el flujo se destruye y la promesa se cumple con true. Si ninguna de las llamadas de fn en los chunks devuelve un valor truthy, la promesa se cumple con 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>

una función para llamar a cada fragmento del flujo. Asincrónico o no.

options

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

Devoluciones

Promise<boolean>

Una promesa que evalúa si trueFN devolvió un valor de Truthy para al menos uno de los chunks.

take(number, Abortable)

Este método devuelve un nuevo flujo con los primeros bloques límite .

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

Parámetros

limit

number

el número de fragmentos que hay que extraer del legible.

options

Abortable

Devoluciones

Readable

Un stream con bloques límite tomados.

toArray(Abortable)

Este método permite obtener fácilmente el contenido de un stream.

Como este método lee todo el flujo en la memoria, anula los beneficios de los flujos. Está pensado para la interoperabilidad y la comodidad, no como la forma principal de consumir streams.

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

Parámetros

options

Abortable

Devoluciones

Promise<any[]>

una promesa que contiene un arreglo con el contenido de la transmisión.

toWeb(ReadableStream, ReadableToWebOptions)

Un método de utilidad para crear una web ReadableStream a partir de un Readablearchivo .

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

Parámetros

streamReadable

ReadableStream

options

ReadableToWebOptions

Devoluciones

ReadableStream<any>

unpipe(WritableStream)

El readable.unpipe() método desprende un Writable arroyo previamente conectado usando el método de la tubería .

Si no se especifica el destination , entonces todas las tuberías se desacoplan.

Si se especifica destination pero no hay tubería configurada para ello, entonces el método no hace 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

Flujo específico opcional para desconectar

Devoluciones

Readable

unshift(any, BufferEncoding)

Pasar chunk como null señala el final del flujo (EOF) y se comporta igual que readable.push(null), tras lo cual no se pueden escribir más datos. La señal EOF se coloca al final del búfer y cualquier dato almacenado en búfer se eliminará.

El readable.unshift() método envía un fragmento de datos de vuelta al búfer interno. Esto es útil en ciertas situaciones en las que un flujo está siendo consumido por código que necesita "desconsumir" cierta cantidad de datos que ha extraído optimistamente de la fuente, para que los datos puedan ser transmitidos a otra parte.

El stream.unshift(chunk) método no puede llamarse después de que el 'end' evento haya sido emitido o se generará un error en tiempo de ejecución.

Los desarrolladores que usen stream.unshift() a menudo deberían considerar cambiar a un Transform stream en su lugar. Consulta la API for stream implementers sección para más información.

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

A diferencia del push, stream.unshift(chunk) no termina el proceso de lectura reiniciando el estado interno de lectura del flujo. Esto puede causar resultados inesperados si readable.unshift() se llama durante una lectura (es decir, desde dentro de una implementación _read en un flujo personalizado). Seguir la llamada con readable.unshift() un empuje inmediato reiniciará el estado de lectura adecuadamente, sin embargo, es mejor evitar llamar readable.unshift() mientras realizas una lectura.

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

Parámetros

chunk

any

Un fragmento de datos para desmover a la cola de lectura. Para flujos que no operan en modo objeto, chunk debe ser una {cadena}, {Buffer}, {TypedArray}, {DataView} o null. Para flujos en modo objeto, chunk puede ser cualquier valor JavaScript.

encoding

BufferEncoding

Codificación de fragmentos de cadena. Debe ser una codificación válida Buffer , como 'utf8' o 'ascii'.

wrap(ReadableStream)

Antes de Node.js 0.10, los flujos no implementaban la API completa node:stream del módulo tal como está definida actualmente. (Véase Compatibility para más información.)

Cuando se utiliza una biblioteca de Node.js antigua que emite 'data' eventos y tiene un método de pausa que es solo asesor, el readable.wrap() método puede usarse para crear un Readable flujo que utilice el flujo antiguo como fuente de datos.

Rara vez será necesario usarlo readable.wrap() , pero el método se ha proporcionado como una comodidad para interactuar con aplicaciones y bibliotecas Node.js antiguas.

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

Un flujo legible "estilo antiguo"

Devoluciones

Readable

[asyncIterator]() 

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

Devoluciones

AsyncIterator<any, undefined, any>

AsyncIterator para consumir completamente el arroyo.

Detalles de los métodos heredados

eventNames()

Devuelve una matriz que enumera los eventos para los que el emisor ha registrado agentes de escucha.

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

Devoluciones

(string | symbol)[]

Heredado de Stream.eventNames

getMaxListeners()

Devuelve el valor máximo actual del agente de escucha para el EventEmitter que se establece mediante emitter.setMaxListeners(n) o los valores predeterminados en events.defaultMaxListeners.

function getMaxListeners(): number

Devoluciones

number

Heredado de Stream.getMaxListeners

pipe<T>(T, PipeOptions) 

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

Parámetros

destination

T

options

PipeOptions

Devoluciones

T

Heredado de Stream.pipe

setMaxListeners(number)

De forma predeterminada, EventEmitters imprimirán una advertencia si se agregan más de 10 agentes de escucha para un evento determinado. Este es un valor predeterminado útil que ayuda a encontrar fugas de memoria. El método emitter.setMaxListeners() permite modificar el límite para esta instancia de EventEmitter específica. El valor se puede establecer en Infinity (o 0) para indicar un número ilimitado de agentes de escucha.

Devuelve una referencia al EventEmitter, para que las llamadas se puedan encadenar.

function setMaxListeners(n: number): Readable

Parámetros

n

number

Devoluciones

Readable

Heredado de Stream.setMaxOyentes

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

El Symbol.for('nodejs.rejection') método se llama en caso de que ocurra un rechazo de promesa al emitir un evento y captureRejections está habilitado en el emisor. Es posible usarlo events.captureRejectionSymbol en 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

error

Error

event

string | symbol

args

any[]

Heredado de Stream.__@captureRejectionSymbol@175