RetriableReadableStream class

Paquete:: @azure/storage-file

SOLO ESTÁ DISPONIBLE EN NODE.JS RUNTIME. Un Node.js ReadableStream reintentará internamente cuando finalice inesperadamente ReadableStream interno.

Extends: Readable

Constructores

RetriableReadableStream(Aborter, ReadableStream, ReadableStreamGetter, number, number, IRetriableReadableStreamOptions)

Crea una instancia de RetriableReadableStream.

Propiedades

destroyed	Se `true` después de llamar a `readable.destroy()`.
readable	Es `true` si es seguro llamar a `readable.read()`, lo que significa que la secuencia no se ha destruido o emitido `'error'` o `'end'`.
readableAborted	Devuelve si la secuencia se ha destruido o se ha producido un error antes de emitir `'end'`.
readableDidRead	Devuelve si se ha emitido `'data'`.
readableEncoding	Captador de la propiedad `encoding` de una secuencia de `Readable` determinada. La propiedad `encoding`se puede establecer mediante el método `readable.setEncoding()`.
readableEnded	Se convierte en `true` cuando se emite `'end'` evento.
readableFlowing	Esta propiedad refleja el estado actual de una secuencia de `Readable` tal y como se describe en la sección `Three states`.
readableHighWaterMark	Devuelve el valor de `highWaterMark` pasado al crear este `Readable`.
readableLength	Esta propiedad contiene el número de bytes (o objetos) de la cola lista para leerse. El valor proporciona datos de introspección con respecto al estado del `highWaterMark`.
readableObjectMode	Captador de la propiedad `objectMode` de una secuencia de `Readable` determinada.

Métodos

addListener("close", () => void)	Emisor de eventos: los eventos definidos en documentos, entre los que se incluyen: cerrar datos fin error pausa legible reanudar
addListener("data", (chunk: any) => void)
addListener("end", () => void)
addListener("error", (err: Error) => void)
addListener("pause", () => void)
addListener("readable", () => void)
addListener("resume", () => void)
addListener(string \| symbol, (args: any[]) => void)
destroy(Error)	Destruye la secuencia. Si lo desea, emita un evento de `'error'` y emita un evento `'close'`(a menos que `emitClose` esté establecido en `false`). Después de esta llamada, la secuencia legible liberará los recursos internos y las llamadas posteriores a `push()`se omitirán. Una vez que `destroy()` se haya llamado a cualquier llamada adicional será un no-op y no se pueden emitir más errores excepto de `_destroy()` como `'error'`. Los implementadores no deben invalidar este método, sino implementar `readable._destroy()`.
emit("close")
emit("data", any)
emit("end")
emit("error", Error)
emit("pause")
emit("readable")
emit("resume")
emit(string \| symbol, any[])
eventNames()	Devuelve una matriz que enumera los eventos para los que el emisor ha registrado agentes de escucha. Los valores de la matriz son cadenas o `Symbol`s. `const EventEmitter = require('events'); const myEE = new EventEmitter(); myEE.on('foo', () => {}); myEE.on('bar', () => {}); const sym = Symbol('symbol'); myEE.on(sym, () => {}); console.log(myEE.eventNames()); // Prints: [ 'foo', 'bar', Symbol(symbol) ]`
from(Iterable<any> \| AsyncIterable<any>, ReadableOptions)	Método de utilidad para crear secuencias legibles fuera de iteradores.
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 <xref:defaultMaxListeners>.
isDisturbed(Readable \| ReadableStream)	Devuelve si la secuencia se ha leído o cancelado.
isPaused()	El método `readable.isPaused()` devuelve el estado operativo actual del`Readable`. Esto se usa principalmente por el mecanismo que subyace al método`readable.pipe()`. En la mayoría de los casos habituales, no habrá ninguna 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`
listenerCount(string \| symbol)	Devuelve el número de agentes de escucha que escuchan el evento denominado `eventName`.
listeners(string \| symbol)	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] ]`
off(string \| symbol, (args: any[]) => void)	Alias para `emitter.removeListener()`.
on("close", () => void)
on("data", (chunk: any) => void)
on("end", () => void)
on("error", (err: Error) => void)
on("pause", () => void)
on("readable", () => void)
on("resume", () => void)
on(string \| symbol, (args: any[]) => void)
once("close", () => void)
once("data", (chunk: any) => void)
once("end", () => void)
once("error", (err: Error) => void)
once("pause", () => void)
once("readable", () => void)
once("resume", () => void)
once(string \| symbol, (args: any[]) => void)
pause()	El método `readable.pause()` hará que una secuencia en modo de flujo deje de emitir eventos de `'data'`, lo que cambiará del modo de flujo. Los datos que estén disponibles permanecerán en el búfer 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 método `readable.pause()` no tiene ningún efecto si hay un agente de escucha de eventos `'readable'`.
pipe<T>(T, undefined \| Object)
prependListener("close", () => void)
prependListener("data", (chunk: any) => void)
prependListener("end", () => void)
prependListener("error", (err: Error) => void)
prependListener("pause", () => void)
prependListener("readable", () => void)
prependListener("resume", () => void)
prependListener(string \| symbol, (args: any[]) => void)
prependOnceListener("close", () => void)
prependOnceListener("data", (chunk: any) => void)
prependOnceListener("end", () => void)
prependOnceListener("error", (err: Error) => void)
prependOnceListener("pause", () => void)
prependOnceListener("readable", () => void)
prependOnceListener("resume", () => void)
prependOnceListener(string \| symbol, (args: any[]) => void)
push(any, BufferEncoding)
rawListeners(string \| symbol)	Devuelve una copia de la matriz de agentes de escucha para el evento denominado `eventName`, incluidos los contenedores (como los creados por `.once()`). 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(undefined \| number)	El método `readable.read()` extrae algunos datos del búfer interno y los devuelve. Si no hay datos disponibles para leerse, se devuelve `null`. De forma predeterminada, los datos se devolverán como un objeto `Buffer` a menos que se haya especificado una codificación mediante el método `readable.setEncoding()` o la secuencia funciona en modo de objeto. El argumento opcional `size` especifica un número específico de bytes que se van a leer. Si`size` bytes no están disponibles para leerse, `null` se devolverá _unless_the secuencia ha finalizado, en cuyo caso se devolverán todos los datos restantes en el búfer interno. Si no se especifica el argumento `size`, se devolverán todos los datos contenidos en el búfer interno. El argumento `size` debe ser menor o igual que 1 GiB. Solo se debe llamar al método `readable.read()` en `Readable` secuencias que funcionan en modo en pausa. En el modo de flujo, se llama a `readable.read()` automáticamente hasta que el búfer interno está completamente purgado. 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 fragmentos no se concatenan. Es necesario un bucle `while` para consumir todos los datos actualmente en el búfer. Al leer un archivo grande `.read()` puede devolver `null`, haber consumido todo el contenido almacenado en búfer hasta ahora, pero todavía hay más datos que no se han almacenado en búfer. En este caso, se emitirá un nuevo evento `'readable'` cuando haya más datos en el búfer. Por último, se emitirá el evento `'end'` cuando no haya más datos. Por lo tanto, para leer todo el contenido de un archivo de un `readable`, es necesario recopilar fragmentos en varios eventos de `'readable'`: `const chunks = []; readable.on('readable', () => { let chunk; while (null !== (chunk = readable.read())) { chunks.push(chunk); } }); readable.on('end', () => { const content = chunks.join(''); });` Una secuencia `Readable` en modo de objeto siempre devolverá un solo elemento de una llamada a `readable.read(size)`, independientemente del valor del argumento`size`. Si el método `readable.read()` devuelve un fragmento de datos, también se emitirá un evento `'data'`. Llamar a <xref:read> después de emitir el evento `'end'` devolverá `null`. No se generará ningún error en tiempo de ejecución.
removeAllListeners(string \| symbol)	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("close", () => void)
removeListener("data", (chunk: any) => void)
removeListener("end", () => void)
removeListener("error", (err: Error) => void)
removeListener("pause", () => void)
removeListener("readable", () => void)
removeListener("resume", () => void)
removeListener(string \| symbol, (args: any[]) => void)
resume()	El método `readable.resume()` hace que una secuencia `Readable` pausa explícitamente reanude la emisión de eventos de `'data'`, cambiando la secuencia al modo de flujo. El método `readable.resume()` se puede usar para consumir completamente los datos de una secuencia sin procesar realmente ninguno de esos datos: `getReadableStreamSomehow() .resume() .on('end', () => { console.log('Reached the end, but did not read anything.'); });` El método `readable.resume()` no tiene ningún efecto si hay un agente de escucha de eventos `'readable'`.
setEncoding(BufferEncoding)	El método `readable.setEncoding()` establece la codificación de caracteres para los datos leídos de la secuencia de `Readable`. De forma predeterminada, no se asigna ninguna codificación y los datos de flujo se devolverán como objetos`Buffer`. Establecer una codificación hace que los datos del flujo se devuelvan como cadenas de la codificación especificada en lugar de como objetos `Buffer`. Por ejemplo, llamar a `readable.setEncoding('utf8')` hará que los datos de salida se interpreten como datos UTF-8 y se pasarán como cadenas. Llamar a`readable.setEncoding('hex')` hará que los datos se codifiquen en formato de cadena hexadecimal. La secuencia de `Readable` controlará correctamente los caracteres de varios bytes entregados a través de la secuencia que, de lo contrario, se descodificarían incorrectamente si simplemente se extraen de la secuencia como objetos `Buffer`. `const readable = getReadableStreamSomehow(); readable.setEncoding('utf8'); readable.on('data', (chunk) => { assert.equal(typeof chunk, 'string'); console.log('Got %d characters of string data:', chunk.length); });`
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.
unpipe(NodeJS.WritableStream)	El método `readable.unpipe()` desasocia una secuencia de `Writable` previamente asociada mediante el método <xref:pipe>. Si no se especifica el `destination`, se desasocian todas las canalizaciones de. Si se especifica el `destination`, pero no se configura ninguna canalización para ella, el método no hace nada. `const fs = require('fs'); const readable = getReadableStreamSomehow(); const writable = fs.createWriteStream('file.txt'); // All the data from readable goes into 'file.txt', // but only for the first second. readable.pipe(writable); setTimeout(() => { console.log('Stop writing to file.txt.'); readable.unpipe(writable); console.log('Manually close the file stream.'); writable.end(); }, 1000);`
unshift(any, BufferEncoding)	Pasar `chunk` como `null` indica el final de la secuencia (EOF) y se comporta igual que `readable.push(null)`, después de lo cual no se pueden escribir más datos. La señal EOF se coloca al final del búfer y los datos almacenados en búfer se seguirán vacíando. El método `readable.unshift()` inserta un fragmento de datos en el búfer interno. Esto resulta útil en determinadas situaciones en las que el código consume una secuencia que necesita "no consumir" cierta cantidad de datos que ha extraído optimistamente del origen, de modo que los datos se puedan pasar a alguna otra parte. No se puede llamar al método `stream.unshift(chunk)` después de que se haya emitido el evento `'end'` o se produzca un error en tiempo de ejecución. Los desarrolladores que usan `stream.unshift()` a menudo deben considerar la posibilidad de cambiar al uso de una secuencia de `Transform` en su lugar. Consulte la sección `API for stream implementers` para obtener 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). const { StringDecoder } = require('string_decoder'); function parseHeader(stream, callback) { stream.on('error', callback); stream.on('readable', onReadable); const decoder = new StringDecoder('utf8'); let header = ''; function onReadable() { let chunk; while (null !== (chunk = stream.read())) { const str = decoder.write(chunk); if (str.match(/\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); } else { // Still reading the header. header += str; } } } } A diferencia de <xref:push>, `stream.unshift(chunk)` no finalizará el proceso de lectura restableciendo el estado de lectura interno de la secuencia. Esto puede provocar resultados inesperados si se llama a `readable.unshift()` durante una lectura (es decir, desde dentro de una implementación de <xref:_read> en una secuencia personalizada). Después de la llamada a `readable.unshift()` con un <xref:push> inmediato restablecerá el estado de lectura adecuadamente, pero es mejor evitar simplemente llamar a `readable.unshift()` mientras está en proceso de realizar una lectura.
wrap(ReadableStream)	Antes de Node.js 0.10, las secuencias no implementaban toda la API del módulo de `stream` tal como se define actualmente. (Consulte `Compatibility` para obtener más información). Cuando se usa una biblioteca de Node.js anterior que emite eventos `'data'` y tiene un método <xref:pause> que solo es de asesoramiento, el método`readable.wrap()` se puede usar para crear una secuencia de `Readable` que use la secuencia antigua como origen de datos. Rara vez será necesario usar `readable.wrap()`, pero el método se ha proporcionado como una comodidad para interactuar con aplicaciones y bibliotecas de Node.js anteriores. `const { OldReader } = require('./old-api-module.js'); const { Readable } = require('stream'); const oreader = new OldReader(); const myReader = new Readable().wrap(oreader); myReader.on('readable', () => { myReader.read(); // etc. });`

Detalles del constructor

RetriableReadableStream(Aborter, ReadableStream, ReadableStreamGetter, number, number, IRetriableReadableStreamOptions)

Crea una instancia de RetriableReadableStream.

new RetriableReadableStream(aborter: Aborter, source: ReadableStream, getter: ReadableStreamGetter, offset: number, count: number, options?: IRetriableReadableStreamOptions)

Parámetros

aborter: Aborter

Cree una nueva instancia de Aborter con Aborter.none o Aborter.timeout(), documentos goto de Aborter para obtener más ejemplos sobre la cancelación de solicitudes.

source: ReadableStream

El objeto ReadableStream actual devuelto desde getter

getter: ReadableStreamGetter

Un método que llama a la solicitud de descarga que devuelve un nuevo ReadableStream desde el desplazamiento especificado

offset: number

Posición de desplazamiento en el origen de datos original que se va a leer

count: number

Cantidad de datos en el origen de datos original que se va a leer

options: IRetriableReadableStreamOptions

Detalles de las propiedades

destroyed

Se true después de llamar a readable.destroy().

destroyed: boolean

Valor de propiedad

boolean

readable

Es true si es seguro llamar a readable.read(), lo que significa que la secuencia no se ha destruido o emitido 'error' o 'end'.

readable: boolean

Valor de propiedad

boolean

readableAborted

Devuelve si la secuencia se ha destruido o se ha producido un error antes de emitir 'end'.

readableAborted: boolean

Valor de propiedad

boolean

readableDidRead

Devuelve si se ha emitido 'data'.

readableDidRead: boolean

Valor de propiedad

boolean

readableEncoding

Captador de la propiedad encoding de una secuencia de Readable determinada. La propiedad encodingse puede establecer mediante el método readable.setEncoding().

readableEncoding: BufferEncoding | null

Valor de propiedad

BufferEncoding | null

readableEnded

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

readableEnded: boolean

Valor de propiedad

boolean

readableFlowing

Esta propiedad refleja el estado actual de una secuencia de Readable tal y como se describe en la sección Three states.

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 (o objetos) de la cola lista para leerse. El valor proporciona datos de introspección con respecto al estado del highWaterMark.

readableLength: number

Valor de propiedad

number

readableObjectMode

Captador de la propiedad objectMode de una secuencia de Readable determinada.

readableObjectMode: boolean

Valor de propiedad

boolean

Detalles del método

addListener("close", () => void)

Emisor de eventos: los eventos definidos en documentos, entre los que se incluyen:

cerrar
datos
fin
error
pausa
legible
reanudar

function addListener(event: "close", listener: () => void)

Parámetros

event: "close"

listener: () => void

Devoluciones

this

addListener("data", (chunk: any) => void)

function addListener(event: "data", listener: (chunk: any) => void)

Parámetros

event: "data"

listener: (chunk: any) => void

Devoluciones

this

addListener("end", () => void)

function addListener(event: "end", listener: () => void)

Parámetros

event: "end"

listener: () => void

Devoluciones

this

addListener("error", (err: Error) => void)

function addListener(event: "error", listener: (err: Error) => void)

Parámetros

event: "error"

listener: (err: Error) => void

Devoluciones

this

addListener("pause", () => void)

function addListener(event: "pause", listener: () => void)

Parámetros

event: "pause"

listener: () => void

Devoluciones

this

addListener("readable", () => void)

function addListener(event: "readable", listener: () => void)

Parámetros

event: "readable"

listener: () => void

Devoluciones

this

addListener("resume", () => void)

function addListener(event: "resume", listener: () => void)

Parámetros

event: "resume"

listener: () => void

Devoluciones

this

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

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

Parámetros

event: string | symbol

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

Devoluciones

this

destroy(Error)

Destruye la secuencia. Si lo desea, emita un evento de 'error' y emita un evento 'close'(a menos que emitClose esté establecido en false). Después de esta llamada, la secuencia legible liberará los recursos internos y las llamadas posteriores a push()se omitirán. Una vez que destroy() se haya llamado a cualquier llamada adicional será un no-op y no se pueden emitir más errores excepto de _destroy() como 'error'.

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

function destroy(error?: Error)

Parámetros

error: Error

Error que se pasará como carga en 'error' evento

emit("close")

function emit(event: "close")

Parámetros

event: "close"

Devoluciones

boolean

emit("data", any)

function emit(event: "data", chunk: any)

Parámetros

event: "data"

chunk: any

Devoluciones

boolean

emit("end")

function emit(event: "end")

Parámetros

event: "end"

Devoluciones

boolean

emit("error", Error)

function emit(event: "error", err: Error)

Parámetros

event: "error"

err: Error

Devoluciones

boolean

emit("pause")

function emit(event: "pause")

Parámetros

event: "pause"

Devoluciones

boolean

emit("readable")

function emit(event: "readable")

Parámetros

event: "readable"

Devoluciones

boolean

emit("resume")

function emit(event: "resume")

Parámetros

event: "resume"

Devoluciones

boolean

emit(string | symbol, any[])

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

Parámetros

event: string | symbol

args: any[]

Devoluciones

boolean

eventNames()

Devuelve una matriz que enumera los eventos para los que el emisor ha registrado agentes de escucha. Los valores de la matriz son cadenas o Symbols.

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

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

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

function eventNames()

Devoluciones

Array<string | symbol>

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

Método de utilidad para crear secuencias legibles fuera de iteradores.

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

Parámetros

iterable: Iterable<any> | AsyncIterable<any>

options: ReadableOptions

Devoluciones

Readable

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 <xref:defaultMaxListeners>.

function getMaxListeners()

Devoluciones

number

isDisturbed(Readable | ReadableStream)

Devuelve si la secuencia se ha leído o cancelado.

static function isDisturbed(stream: Readable | ReadableStream)

Parámetros

stream: Readable | ReadableStream

Devoluciones

boolean

isPaused()

El método readable.isPaused() devuelve el estado operativo actual delReadable. Esto se usa principalmente por el mecanismo que subyace al métodoreadable.pipe(). En la mayoría de los casos habituales, no habrá ninguna 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()

Devoluciones

boolean

listenerCount(string | symbol)

Devuelve el número de agentes de escucha que escuchan el evento denominado eventName.

function listenerCount(eventName: string | symbol)

Parámetros

eventName: string | symbol

Nombre del evento que se está escuchando

Devoluciones

number

listeners(string | symbol)

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(eventName: string | symbol)

Parámetros

eventName: string | symbol

Devoluciones

Function[]

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

Alias para emitter.removeListener().

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

Parámetros

eventName: string | symbol

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

Devoluciones

this

on("close", () => void)

function on(event: "close", listener: () => void)

Parámetros

event: "close"

listener: () => void

Devoluciones

this

on("data", (chunk: any) => void)

function on(event: "data", listener: (chunk: any) => void)

Parámetros

event: "data"

listener: (chunk: any) => void

Devoluciones

this

on("end", () => void)

function on(event: "end", listener: () => void)

Parámetros

event: "end"

listener: () => void

Devoluciones

this

on("error", (err: Error) => void)

function on(event: "error", listener: (err: Error) => void)

Parámetros

event: "error"

listener: (err: Error) => void

Devoluciones

this

on("pause", () => void)

function on(event: "pause", listener: () => void)

Parámetros

event: "pause"

listener: () => void

Devoluciones

this

on("readable", () => void)

function on(event: "readable", listener: () => void)

Parámetros

event: "readable"

listener: () => void

Devoluciones

this

on("resume", () => void)

function on(event: "resume", listener: () => void)

Parámetros

event: "resume"

listener: () => void

Devoluciones

this

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

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

Parámetros

event: string | symbol

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

Devoluciones

this

once("close", () => void)

function once(event: "close", listener: () => void)

Parámetros

event: "close"

listener: () => void

Devoluciones

this

once("data", (chunk: any) => void)

function once(event: "data", listener: (chunk: any) => void)

Parámetros

event: "data"

listener: (chunk: any) => void

Devoluciones

this

once("end", () => void)

function once(event: "end", listener: () => void)

Parámetros

event: "end"

listener: () => void

Devoluciones

this

once("error", (err: Error) => void)

function once(event: "error", listener: (err: Error) => void)

Parámetros

event: "error"

listener: (err: Error) => void

Devoluciones

this

once("pause", () => void)

function once(event: "pause", listener: () => void)

Parámetros

event: "pause"

listener: () => void

Devoluciones

this

once("readable", () => void)

function once(event: "readable", listener: () => void)

Parámetros

event: "readable"

listener: () => void

Devoluciones

this

once("resume", () => void)

function once(event: "resume", listener: () => void)

Parámetros

event: "resume"

listener: () => void

Devoluciones

this

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

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

Parámetros

event: string | symbol

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

Devoluciones

this

pause()

El método readable.pause() hará que una secuencia en modo de flujo deje de emitir eventos de 'data', lo que cambiará del modo de flujo. Los datos que estén disponibles permanecerán en el búfer 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 método readable.pause() no tiene ningún efecto si hay un agente de escucha de eventos 'readable'.

function pause()

Devoluciones

this

pipe<T>(T, undefined | Object)

function pipe<T>(destination: T, options?: undefined | Object)

Parámetros

destination: T

options: undefined | Object

Devoluciones

prependListener("close", () => void)

function prependListener(event: "close", listener: () => void)

Parámetros

event: "close"

listener: () => void

Devoluciones

this

prependListener("data", (chunk: any) => void)

function prependListener(event: "data", listener: (chunk: any) => void)

Parámetros

event: "data"

listener: (chunk: any) => void

Devoluciones

this

prependListener("end", () => void)

function prependListener(event: "end", listener: () => void)

Parámetros

event: "end"

listener: () => void

Devoluciones

this

prependListener("error", (err: Error) => void)

function prependListener(event: "error", listener: (err: Error) => void)

Parámetros

event: "error"

listener: (err: Error) => void

Devoluciones

this

prependListener("pause", () => void)

function prependListener(event: "pause", listener: () => void)

Parámetros

event: "pause"

listener: () => void

Devoluciones

this

prependListener("readable", () => void)

function prependListener(event: "readable", listener: () => void)

Parámetros

event: "readable"

listener: () => void

Devoluciones

this

prependListener("resume", () => void)

function prependListener(event: "resume", listener: () => void)

Parámetros

event: "resume"

listener: () => void

Devoluciones

this

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

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

Parámetros

event: string | symbol

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

Devoluciones

this

prependOnceListener("close", () => void)

function prependOnceListener(event: "close", listener: () => void)

Parámetros

event: "close"

listener: () => void

Devoluciones

this

prependOnceListener("data", (chunk: any) => void)

function prependOnceListener(event: "data", listener: (chunk: any) => void)

Parámetros

event: "data"

listener: (chunk: any) => void

Devoluciones

this

prependOnceListener("end", () => void)

function prependOnceListener(event: "end", listener: () => void)

Parámetros

event: "end"

listener: () => void

Devoluciones

this

prependOnceListener("error", (err: Error) => void)

function prependOnceListener(event: "error", listener: (err: Error) => void)

Parámetros

event: "error"

listener: (err: Error) => void

Devoluciones

this

prependOnceListener("pause", () => void)

function prependOnceListener(event: "pause", listener: () => void)

Parámetros

event: "pause"

listener: () => void

Devoluciones

this

prependOnceListener("readable", () => void)

function prependOnceListener(event: "readable", listener: () => void)

Parámetros

event: "readable"

listener: () => void

Devoluciones

this

prependOnceListener("resume", () => void)

function prependOnceListener(event: "resume", listener: () => void)

Parámetros

event: "resume"

listener: () => void

Devoluciones

this

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

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

Parámetros

event: string | symbol

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

Devoluciones

this

push(any, BufferEncoding)

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

Parámetros

chunk: any

encoding: BufferEncoding

Devoluciones

boolean

rawListeners(string | symbol)

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

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(eventName: string | symbol)

Parámetros

eventName: string | symbol

Devoluciones

Function[]

read(undefined | number)

El método readable.read() extrae algunos datos del búfer interno y los devuelve. Si no hay datos disponibles para leerse, se devuelve null. De forma predeterminada, los datos se devolverán como un objeto Buffer a menos que se haya especificado una codificación mediante el método readable.setEncoding() o la secuencia funciona en modo de objeto. El argumento opcional size especifica un número específico de bytes que se van a leer. Sisize bytes no están disponibles para leerse, null se devolverá _unless_the secuencia ha finalizado, en cuyo caso se devolverán todos los datos restantes en el búfer interno.

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

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

Solo se debe llamar al método readable.read() en Readable secuencias que funcionan en modo en pausa. En el modo de flujo, se llama a readable.read() automáticamente hasta que el búfer interno está completamente purgado.

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 fragmentos no se concatenan. Es necesario un bucle while para consumir todos los datos actualmente en el búfer. Al leer un archivo grande .read() puede devolver null, haber consumido todo el contenido almacenado en búfer hasta ahora, pero todavía hay más datos que no se han almacenado en búfer. En este caso, se emitirá un nuevo evento 'readable' cuando haya más datos en el búfer. Por último, se emitirá el evento 'end' cuando no haya más datos.

Por lo tanto, para leer todo el contenido de un archivo de un readable, es necesario recopilar fragmentos en varios eventos de 'readable':

const chunks = [];

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

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

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

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

Llamar a <xref:read> después de emitir el evento 'end' devolverá null. No se generará ningún error en tiempo de ejecución.

function read(size?: undefined | number)

Parámetros

size: undefined | number

Argumento opcional para especificar la cantidad de datos que se van a leer.

Devoluciones

any

removeAllListeners(string | symbol)

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(event?: string | symbol)

Parámetros

event: string | symbol

Devoluciones

this

removeListener("close", () => void)

function removeListener(event: "close", listener: () => void)

Parámetros

event: "close"

listener: () => void

Devoluciones

this

removeListener("data", (chunk: any) => void)

function removeListener(event: "data", listener: (chunk: any) => void)

Parámetros

event: "data"

listener: (chunk: any) => void

Devoluciones

this

removeListener("end", () => void)

function removeListener(event: "end", listener: () => void)

Parámetros

event: "end"

listener: () => void

Devoluciones

this

removeListener("error", (err: Error) => void)

function removeListener(event: "error", listener: (err: Error) => void)

Parámetros

event: "error"

listener: (err: Error) => void

Devoluciones

this

removeListener("pause", () => void)

function removeListener(event: "pause", listener: () => void)

Parámetros

event: "pause"

listener: () => void

Devoluciones

this

removeListener("readable", () => void)

function removeListener(event: "readable", listener: () => void)

Parámetros

event: "readable"

listener: () => void

Devoluciones

this

removeListener("resume", () => void)

function removeListener(event: "resume", listener: () => void)

Parámetros

event: "resume"

listener: () => void

Devoluciones

this

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

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

Parámetros

event: string | symbol

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

Devoluciones

this

resume()

El método readable.resume() hace que una secuencia Readable pausa explícitamente reanude la emisión de eventos de 'data', cambiando la secuencia al modo de flujo. El método readable.resume() se puede usar para consumir completamente los datos de una secuencia sin procesar realmente ninguno de esos datos:

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

El método readable.resume() no tiene ningún efecto si hay un agente de escucha de eventos 'readable'.

function resume()

Devoluciones

this

setEncoding(BufferEncoding)

El método readable.setEncoding() establece la codificación de caracteres para los datos leídos de la secuencia de Readable. De forma predeterminada, no se asigna ninguna codificación y los datos de flujo se devolverán como objetosBuffer. Establecer una codificación hace que los datos del flujo se devuelvan como cadenas de la codificación especificada en lugar de como objetos Buffer. Por ejemplo, llamar a readable.setEncoding('utf8') hará que los datos de salida se interpreten como datos UTF-8 y se pasarán como cadenas. Llamar areadable.setEncoding('hex') hará que los datos se codifiquen en formato de cadena hexadecimal.

La secuencia de Readable controlará correctamente los caracteres de varios bytes entregados a través de la secuencia que, de lo contrario, se descodificarían incorrectamente si simplemente se extraen de la secuencia como objetos Buffer.

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

function setEncoding(encoding: BufferEncoding)

Parámetros

encoding: BufferEncoding

Codificación que se va a usar.

Devoluciones

this

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

Parámetros

n: number

Devoluciones

this

unpipe(NodeJS.WritableStream)

El método readable.unpipe() desasocia una secuencia de Writable previamente asociada mediante el método <xref:pipe>. Si no se especifica el destination, se desasocian todas las canalizaciones de.

Si se especifica el destination, pero no se configura ninguna canalización para ella, el método no hace nada.

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

function unpipe(destination?: NodeJS.WritableStream)

Parámetros

destination: NodeJS.WritableStream

Secuencia específica opcional para despipear

Devoluciones

this

unshift(any, BufferEncoding)

Pasar chunk como null indica el final de la secuencia (EOF) y se comporta igual que readable.push(null), después de lo cual no se pueden escribir más datos. La señal EOF se coloca al final del búfer y los datos almacenados en búfer se seguirán vacíando. El método readable.unshift() inserta un fragmento de datos en el búfer interno. Esto resulta útil en determinadas situaciones en las que el código consume una secuencia que necesita "no consumir" cierta cantidad de datos que ha extraído optimistamente del origen, de modo que los datos se puedan pasar a alguna otra parte.

No se puede llamar al método stream.unshift(chunk) después de que se haya emitido el evento 'end' o se produzca un error en tiempo de ejecución.

Los desarrolladores que usan stream.unshift() a menudo deben considerar la posibilidad de cambiar al uso de una secuencia de Transform en su lugar. Consulte la sección API for stream implementers para obtener 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).
const { StringDecoder } = require('string_decoder');
function parseHeader(stream, callback) {
  stream.on('error', callback);
  stream.on('readable', onReadable);
  const decoder = new StringDecoder('utf8');
  let header = '';
  function onReadable() {
    let chunk;
    while (null !== (chunk = stream.read())) {
      const str = decoder.write(chunk);
      if (str.match(/\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);
      } else {
        // Still reading the header.
        header += str;
      }
    }
  }
}

A diferencia de <xref:push>, stream.unshift(chunk) no finalizará el proceso de lectura restableciendo el estado de lectura interno de la secuencia. Esto puede provocar resultados inesperados si se llama a readable.unshift() durante una lectura (es decir, desde dentro de una implementación de <xref:_read> en una secuencia personalizada). Después de la llamada a readable.unshift() con un <xref:push> inmediato restablecerá el estado de lectura adecuadamente, pero es mejor evitar simplemente llamar a readable.unshift() mientras está en proceso de realizar una lectura.

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

Parámetros

chunk: any

Fragmento de datos que se van a desactivar en la cola de lectura. Para las secuencias que no funcionan en modo de objeto, chunk deben ser una cadena, Buffer, Uint8Array o null. En el caso de los flujos de modo de objeto, chunk puede ser cualquier valor de JavaScript.

encoding: BufferEncoding

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

wrap(ReadableStream)

Antes de Node.js 0.10, las secuencias no implementaban toda la API del módulo de stream tal como se define actualmente. (Consulte Compatibility para obtener más información). Cuando se usa una biblioteca de Node.js anterior que emite eventos 'data' y tiene un método <xref:pause> que solo es de asesoramiento, el métodoreadable.wrap() se puede usar para crear una secuencia de Readable que use la secuencia antigua como origen de datos.

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

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

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

function wrap(stream: ReadableStream)

Parámetros

stream: ReadableStream

Secuencia legible de "estilo antiguo"

Devoluciones

this

Comentarios

¿Le ha resultado útil esta página?