Readable interface

Paquete:: @azure/storage-common

Extends: Stream

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)	Alias para `emitter.on(eventName, listener)`.
compose(WritableStream \| WritableStream \| TransformStream \| (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])	Llama sincrónicamente a cada uno de los agentes de escucha registrados para el evento denominado `eventName`, en el orden en que se registraron, pasando los argumentos proporcionados a cada uno. Devuelve `true` si el evento tenía agentes de escucha, `false` de lo contrario. import { EventEmitter } from 'node:events'; const myEmitter = new EventEmitter(); // First listener myEmitter.on('event', function firstListener() { console.log('Helloooo! first listener'); }); // Second listener myEmitter.on('event', function secondListener(arg1, arg2) { console.log(`event with parameters ${arg1}, ${arg2} in second listener`); }); // Third listener myEmitter.on('event', function thirdListener(...args) { const parameters = args.join(', '); console.log(`event with parameters ${parameters} in third listener`); }); console.log(myEmitter.listeners('event')); myEmitter.emit('event', 1, 2, 3, 4, 5); // Prints: // [ // [Function: firstListener], // [Function: secondListener], // [Function: thirdListener] // ] // Helloooo! first listener // event with parameters 1, 2 in second listener // event with parameters 1, 2, 3, 4, 5 in third listener
every((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	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 `await`es 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á `await`ed.
find((data: any, options?: Abortable) => boolean \| Promise<boolean>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)
find<T>((data: any, options?: Abortable) => data is T, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	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, "concurrency" \| "signal">)	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, "concurrency" \| "signal">)	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á `await`ed. 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.
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)	Devuelve el número de agentes de escucha que escuchan el evento denominado `eventName`. Si se proporciona `listener`, devolverá cuántas veces se encuentra el agente de escucha en la lista de agentes de escucha del evento.
listeners(string \| symbol)
listeners<E>(E)	Devuelve una copia de la matriz de agentes de escucha del evento denominado `eventName`. `server.on('connection', (stream) => { console.log('someone connected!'); }); console.log(util.inspect(server.listeners('connection'))); // Prints: [ [Function] ]`
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á `await`ed antes de ser pasada al flujo de resultados.
off(string \| symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)	Alias para `emitter.removeListener()`.
on(string \| symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)	Agrega la función `listener` al final de la matriz de agentes de escucha para el evento denominado `eventName`. No se realizan comprobaciones para ver si ya se ha agregado el `listener`. Varias llamadas que pasan la misma combinación de `eventName` y `listener` darán lugar a que se agregue el `listener` y se llame varias veces. `server.on('connection', (stream) => { console.log('someone connected!'); });` Devuelve una referencia al `EventEmitter`, para que las llamadas se puedan encadenar. De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El método `emitter.prependListener()` se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha. `import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.on('foo', () => console.log('a')); myEE.prependListener('foo', () => console.log('b')); myEE.emit('foo'); // Prints: // b // a`
once(string \| symbol, (args: any[]) => void)
once<E>(E, (args: ReadableEventMap[E]) => void)	Agrega una función de única para el evento denominado . La próxima vez que se desencadene `eventName`, se quita este agente de escucha y, a continuación, se invoca. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` Devuelve una referencia al `EventEmitter`, para que las llamadas se puedan encadenar. De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El método `emitter.prependOnceListener()` se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha. `import { EventEmitter } from 'node:events'; const myEE = new EventEmitter(); myEE.once('foo', () => console.log('a')); myEE.prependOnceListener('foo', () => console.log('b')); myEE.emit('foo'); // Prints: // b // a`
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)	Agrega la función `listener` al que comienza de la matriz de agentes de escucha para el evento denominado `eventName`. No se realizan comprobaciones para ver si ya se ha agregado el `listener`. Varias llamadas que pasan la misma combinación de `eventName` y `listener` darán lugar a que se agregue el `listener` y se llame varias veces. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` Devuelve una referencia al `EventEmitter`, para que las llamadas se puedan encadenar.
prependOnceListener(string \| symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)	Agrega una función de de única para el evento denominado al principio de la matriz de agentes de escucha. La próxima vez que se desencadene `eventName`, se quita este agente de escucha y, a continuación, se invoca. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` Devuelve una referencia al `EventEmitter`, para que las llamadas se puedan encadenar.
push(any, BufferEncoding)
rawListeners(string \| symbol)
rawListeners<E>(E)	Devuelve una copia de la matriz de agentes de escucha para el evento denominado `eventName`, incluidos los contenedores (como los creados por `.once()`). import { EventEmitter } from 'node:events'; const emitter = new EventEmitter(); emitter.once('log', () => console.log('log once')); // Returns a new Array with a function `onceWrapper` which has a property // `listener` which contains the original listener bound above const listeners = emitter.rawListeners('log'); const logFnWrapper = listeners[0]; // Logs "log once" to the console and does not unbind the `once` event logFnWrapper.listener(); // Logs "log once" to the console and removes the listener logFnWrapper(); emitter.on('log', () => console.log('log persistently')); // Will return a new Array with a single function bound by `.on()` above const newListeners = emitter.rawListeners('log'); // Logs "log persistently" twice newListeners[0](); emitter.emit('log');
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)	Quita todos los agentes de escucha o los del `eventName`especificado. Es un procedimiento incorrecto quitar agentes de escucha agregados en otro lugar del código, especialmente cuando la instancia de `EventEmitter` se creó mediante algún otro componente o módulo (por ejemplo, sockets o flujos de archivos). Devuelve una referencia al `EventEmitter`, para que las llamadas se puedan encadenar.
removeListener(string \| symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)	Quita el `listener` especificado de la matriz del agente de escucha para el evento denominado `eventName`. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` quitará, como máximo, una instancia de un agente de escucha de la matriz del agente de escucha. Si se ha agregado varias veces alguna escucha única a la matriz del agente de escucha para el `eventName`especificado, se debe llamar a `removeListener()` varias veces para quitar cada instancia. Una vez emitido un evento, se llama a todos los agentes de escucha adjuntos en el momento de emitir en orden. Esto implica que cualquier `removeListener()removeAllListeners()` llamada tras emitir y antes de que el último oyente termine la ejecución no las eliminará del `emit()` proceso de ejecución. Los eventos posteriores se comportan según lo previsto. import { EventEmitter } from 'node:events'; class MyEmitter extends EventEmitter {} const myEmitter = new MyEmitter(); const callbackA = () => { console.log('A'); myEmitter.removeListener('event', callbackB); }; const callbackB = () => { console.log('B'); }; myEmitter.on('event', callbackA); myEmitter.on('event', callbackB); // callbackA removes listener callbackB but it will still be called. // Internal listener array at time of emit [callbackA, callbackB] myEmitter.emit('event'); // Prints: // A // B // callbackB is now removed. // Internal listener array [callbackA] myEmitter.emit('event'); // Prints: // A Como los oyentes se gestionan mediante un array interno, llamar a esto cambiará los índices de posición de cualquier oyente registrado tras la eliminación del oyente. Esto no afectará al orden en el que se llama a los agentes de escucha, pero significa que las copias de la matriz del agente de escucha tal y como devuelve el método `emitter.listeners()` deberán volver a crearse. Cuando se ha agregado una sola función como controlador varias veces para un solo evento (como en el ejemplo siguiente), `removeListener()` quitará la instancia agregada más recientemente. En el ejemplo, se quita el agente de escucha `once('ping')`: `import { EventEmitter } from 'node:events'; const ee = new EventEmitter(); function pong() { console.log('pong'); } ee.on('ping', pong); ee.once('ping', pong); ee.removeListener('ping', pong); ee.emit('ping'); ee.emit('ping');` Devuelve una referencia al `EventEmitter`, para que las llamadas se puedan encadenar.
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, "concurrency" \| "signal">)	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 `await`ed 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.
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. });`
[asyncDispose]()	Llama `readable.destroy()` con un `AbortError` y devuelve una promesa que se cumple cuando termina la transmisión.
[asyncIterator]()
[toAsyncStreamable]()	Cuando la `--experimental-stream-iter` bandera está activada, `Readable` los flujos implementan el `Stream.toAsyncStreamable` protocolo, permitiendo un consumo eficiente por parte de la `stream/iter` API. Esto proporciona un iterador asíncrono agrupado que drena el búfer interno del flujo en `Uint8Array[]` lotes, amortizando la sobrecarga Promise por bloque del camino estándar `Symbol.asyncIterator` . Para flujos en modo byte, los chunks se obtienen directamente como `Buffer` instancias (que son `Uint8Array` subclases). Para flujos en modo objeto o codificados, cada chunk se normaliza a `Uint8Array` antes de agruparse. El iterador devuelto se etiqueta como fuente validada, por lo que `from()` lo pasa sin normalización adicional. `import { Readable } from 'node:stream'; import { text, from } from 'node:stream/iter'; const readable = new Readable({ read() { this.push('hello'); this.push(null); }, }); // Readable is automatically consumed via toAsyncStreamable console.log(await text(from(readable))); // 'hello'` Sin la `--experimental-stream-iter` bandera, llamar a este método lanza `ERR_STREAM_ITER_MISSING_FLAG`.

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, `EventEmitter`s 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 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: Error | null

Valor de propiedad

Error | null

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: BufferEncoding | null

Valor de propiedad

BufferEncoding | null

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: boolean | null

Valor de propiedad

boolean | null

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

Parámetros

eventName: string | symbol

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

Devoluciones

this

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

Alias para emitter.on(eventName, listener).

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

Parámetros

eventName: E

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

Devoluciones

this

compose(WritableStream | WritableStream | TransformStream | (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 | TransformStream | (source: any) => void, options?: Abortable): Duplex

Parámetros

stream: WritableStream | WritableStream | TransformStream | (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): this

Parámetros

error: Error

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

Devoluciones

this

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

Llama sincrónicamente a cada uno de los agentes de escucha registrados para el evento denominado eventName, en el orden en que se registraron, pasando los argumentos proporcionados a cada uno.

Devuelve true si el evento tenía agentes de escucha, false de lo contrario.

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

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

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

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

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

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

Parámetros

eventName: E

args: ReadableEventMap[E]

Devoluciones

boolean

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

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, "concurrency" | "signal">): 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, "concurrency" | "signal">

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, "concurrency" | "signal">)

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

Parámetros

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

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

Devoluciones

Promise<any>

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

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 is T, options?: Pick<ReadableOperatorOptions, "concurrency" | "signal">): Promise<T | undefined>

Parámetros

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

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

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

Devoluciones

Promise<T | undefined>

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, "concurrency" | "signal">)

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, "concurrency" | "signal">): 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, "concurrency" | "signal">

Devoluciones

Readable

un flujo mapeado plano con la función fn.

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

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, "concurrency" | "signal">): 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, "concurrency" | "signal">

Devoluciones

Promise<void>

una promesa para cuando el stream termine.

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>

Parámetros

options: ReadableIteratorOptions

Devoluciones

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

Devuelve el número de agentes de escucha que escuchan el evento denominado eventName. Si se proporciona listener, devolverá cuántas veces se encuentra el agente de escucha en la lista de agentes de escucha del evento.

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

Parámetros

eventName: E

Nombre del evento que se está escuchando

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

Función del controlador de eventos

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)

Devuelve una copia de la matriz de agentes de escucha del evento denominado eventName.

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

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

Parámetros

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

Parámetros

eventName: string | symbol

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

Devoluciones

this

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

Alias para emitter.removeListener().

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

Parámetros

eventName: E

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

Devoluciones

this

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

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

Parámetros

eventName: string | symbol

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

Devoluciones

this

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

Agrega la función listener al final de la matriz de agentes de escucha para el evento denominado eventName. No se realizan comprobaciones para ver si ya se ha agregado el listener. Varias llamadas que pasan la misma combinación de eventName y listener darán lugar a que se agregue el listener y se llame varias veces.

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

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

De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El método emitter.prependListener() se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha.

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

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

Parámetros

eventName: E

Nombre del evento.

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

Función de devolución de llamada

Devoluciones

this

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

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

Parámetros

eventName: string | symbol

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

Devoluciones

this

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

Agrega una función de única para el evento denominado . La próxima vez que se desencadene eventName, se quita este agente de escucha y, a continuación, se invoca.

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

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

De forma predeterminada, los agentes de escucha de eventos se invocan en el orden en que se agregan. El método emitter.prependOnceListener() se puede usar como alternativa para agregar el agente de escucha de eventos al principio de la matriz de agentes de escucha.

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

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

Parámetros

eventName: E

Nombre del evento.

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

Función de devolución de llamada

Devoluciones

this

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

Devoluciones

this

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

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

Parámetros

eventName: string | symbol

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

Devoluciones

this

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

Agrega la función listener al que comienza de la matriz de agentes de escucha para el evento denominado eventName. No se realizan comprobaciones para ver si ya se ha agregado el listener. Varias llamadas que pasan la misma combinación de eventName y listener darán lugar a que se agregue el listener y se llame varias veces.

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

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

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

Parámetros

eventName: E

Nombre del evento.

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

Función de devolución de llamada

Devoluciones

this

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

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

Parámetros

eventName: string | symbol

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

Devoluciones

this

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

Agrega una función de de única para el evento denominado al principio de la matriz de agentes de escucha. La próxima vez que se desencadene eventName, se quita este agente de escucha y, a continuación, se invoca.

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

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

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

Parámetros

eventName: E

Nombre del evento.

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

Función de devolución de llamada

Devoluciones

this

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)

Devuelve una copia de la matriz de agentes de escucha para el evento denominado eventName, incluidos los contenedores (como los creados por .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

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

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

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

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

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

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

Parámetros

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

Parámetros

eventName: string | symbol

Devoluciones

this

removeAllListeners<E>(E)

Quita todos los agentes de escucha o los del eventNameespecificado.

Es un procedimiento incorrecto quitar agentes de escucha agregados en otro lugar del código, especialmente cuando la instancia de EventEmitter se creó mediante algún otro componente o módulo (por ejemplo, sockets o flujos de archivos).

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

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

Parámetros

eventName: E

Devoluciones

this

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

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

Parámetros

eventName: string | symbol

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

Devoluciones

this

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

Quita el listener especificado de la matriz del agente de escucha para el evento denominado eventName.

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

removeListener() quitará, como máximo, una instancia de un agente de escucha de la matriz del agente de escucha. Si se ha agregado varias veces alguna escucha única a la matriz del agente de escucha para el eventNameespecificado, se debe llamar a removeListener() varias veces para quitar cada instancia.

Una vez emitido un evento, se llama a todos los agentes de escucha adjuntos en el momento de emitir en orden. Esto implica que cualquier removeListener()removeAllListeners() llamada tras emitir y antes de que el último oyente termine la ejecución no las eliminará del emit() proceso de ejecución. Los eventos posteriores se comportan según lo previsto.

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

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

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

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

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

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

Como los oyentes se gestionan mediante un array interno, llamar a esto cambiará los índices de posición de cualquier oyente registrado tras la eliminación del oyente. Esto no afectará al orden en el que se llama a los agentes de escucha, pero significa que las copias de la matriz del agente de escucha tal y como devuelve el método emitter.listeners() deberán volver a crearse.

Cuando se ha agregado una sola función como controlador varias veces para un solo evento (como en el ejemplo siguiente), removeListener() quitará la instancia agregada más recientemente. En el ejemplo, se quita el agente de escucha once('ping'):

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

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

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

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

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

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

Parámetros

eventName: E

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

Devoluciones

this

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

Devoluciones

this

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

Parámetros

encoding: BufferEncoding

Codificación que se va a usar.

Devoluciones

this

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

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, "concurrency" | "signal">): 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, "concurrency" | "signal">

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.

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

Parámetros

destination: WritableStream

Flujo específico opcional para desconectar

Devoluciones

this

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

Parámetros

stream: ReadableStream

Un flujo legible "estilo antiguo"

Devoluciones

this

[asyncDispose]()

Llama readable.destroy() con un AbortError y devuelve una promesa que se cumple cuando termina la transmisión.

function [asyncDispose](): Promise<void>

Devoluciones

Promise<void>

[asyncIterator]()

function [asyncIterator](): AsyncIterator<any>

Devoluciones

AsyncIterator<any>

AsyncIterator para consumir completamente el arroyo.

[toAsyncStreamable]()

Cuando la --experimental-stream-iter bandera está activada, Readable los flujos implementan el Stream.toAsyncStreamable protocolo, permitiendo un consumo eficiente por parte de la stream/iter API.

Esto proporciona un iterador asíncrono agrupado que drena el búfer interno del flujo en Uint8Array[] lotes, amortizando la sobrecarga Promise por bloque del camino estándar Symbol.asyncIterator . Para flujos en modo byte, los chunks se obtienen directamente como Buffer instancias (que son Uint8Array subclases). Para flujos en modo objeto o codificados, cada chunk se normaliza a Uint8Array antes de agruparse.

El iterador devuelto se etiqueta como fuente validada, por lo que from() lo pasa sin normalización adicional.

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

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

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

Sin la --experimental-stream-iter bandera, llamar a este método lanza ERR_STREAM_ITER_MISSING_FLAG.

function [toAsyncStreamable](): ByteReadableStream

Devoluciones

ByteReadableStream

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

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

Parámetros

n: number

Devoluciones

this

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. [capturaSímboloRechazo]