Readable interface

Pacchetto:: @azure/storage-common

Extends: Stream

Proprietà

closed	È `true` dopo `'close'` che è stato emesso.
destroyed	È `true` dopo `readable.destroy()` che è stato chiamato.
errored	Restituisce errore se il flusso è stato distrutto con un errore.
readable	È `true` se è sicuro chiamare read, il che significa che il flusso non è stato distrutto o emesso `'error'` o `'end'`.
readableAborted	Restituisce se il flusso è stato distrutto o ha commesso un errore prima di emettere `'end'`.
readableDidRead	Restituisce se `'data'` è stato emesso.
readableEncoding	Getter per la proprietà `encoding` di un dato `Readable` ruscello. La `encoding` proprietà può essere impostata usando il metodo setEncoding .
readableEnded	Diventa `true` quando `'end'` viene emesso un evento.
readableFlowing	Questa proprietà riflette lo stato attuale di un `Readable` corso d'acqua come descritto nella sezione dei Tre stati .
readableHighWaterMark	Restituisce il valore di `highWaterMark` passato quando si crea questo `Readable`.
readableLength	Questa proprietà contiene il numero di byte (o oggetti) nella coda pronti per essere letti. Il valore fornisce dati di introspezione riguardanti lo `highWaterMark`stato del .
readableObjectMode	Getter per la proprietà `objectMode` di un dato `Readable` ruscello.

Metodi

addListener(string \| symbol, (args: any[]) => void)
addListener<E>(E, (args: ReadableEventMap[E]) => void)	Alias per `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)` è pari a `stream.compose(readable, s)`. Questo metodo consente anche di fornire un `AbortSignal` , che distruggerà il flusso composto se abortito. Per altre informazioni, vedere `stream.compose(...streams)`.
destroy(Error)	Distruggi il flusso. Opzionalmente emetti un `'error'` evento e un `'close'` evento (a meno che `emitClose` non sia impostato su `false`). Dopo questa chiamata, il flusso leggibile rilascia tutte le risorse interne e le chiamate successive `push()` verranno ignorate. Una volta `destroy()` chiamata, eventuali ulteriori chiamate saranno no-op e non possono essere emessi `_destroy()`altri errori tranne da `'error'` . Gli implementatori non dovrebbero sovrascrivere questo metodo, ma implementare `readable._destroy()`invece .
drop(number, Abortable)	Questo metodo restituisce un nuovo flusso con i primi blocchi di limite eliminati dall'inizio.
emit(string \| symbol, any[])
emit<E>(E, ReadableEventMap[E])	Chiama in modo sincrono ogni listener registrato per l'evento denominato `eventName`, nell'ordine in cui sono stati registrati, passando gli argomenti forniti a ognuno. Restituisce `true` se l'evento include listener, `false` in caso 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">)	Questo metodo è simile a `Array.prototype.every` and calls fn su ogni chunk dello stream per verificare se tutti i valori di ritorno attesi siano veri valori per fn. Una volta che una chiamata fn su un valore di ritorno ed a chunk `await`è falsa, il flusso viene distrutto e la promessa viene mantenuta con `false`. Se tutte le chiamate fn sui chunks restituiscono un valore truthy, la promessa viene mantenuta con `true`.
filter((data: any, options?: Abortable) => boolean \| Promise<boolean>, ReadableOperatorOptions)	Questo metodo permette di filtrare il flusso. Per ogni chunk del flusso verrà chiamata la funzione fn e se restituisce un valore truthy, il chunk verrà passato al flusso risultato. Se la funzione fn restituisce una promessa, quella promessa sarà `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">)	Questo metodo è simile a `Array.prototype.find` e chiama fn su ogni chunk del flusso per trovare un chunk con un valore truthy per fn. Una volta che il valore atteso di ritorno di una chiamata fn è truthy, lo stream viene distrutto e la promessa viene mantenuta con un valore per il quale fn ha restituito un valore truthy. Se tutte le chiamate fn sui chunks restituiscono un valore falso, la promessa viene mantenuta con `undefined`.
flatMap((data: any, options?: Abortable) => any, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Questo metodo restituisce un nuovo flusso applicando il callback dato a ogni blocco del flusso e poi appiattendo il risultato. È possibile restituire uno stream o un altro iterabile o asincrono da fn e i flussi risultanti verranno uniti (appiattiti) nel flusso restituito.
forEach((data: any, options?: Abortable) => void \| Promise<void>, Pick<ReadableOperatorOptions, "concurrency" \| "signal">)	Questo metodo permette di iterare un flusso. Per ogni chunk del flusso verrà chiamata la funzione fn . Se la funzione fn restituisce una promessa, quella promessa sarà `await`ed. Questo metodo è diverso dai `for await...of` loop in quanto può opzionalmente elaborare i chunk contemporaneamente. Inoltre, un'iterazione `forEach` può essere fermata solo avendo superato un'opzione `signal` e abortendo l'AbortController correlato mentre `for await...of` può essere fermata con `break` o `return`. In entrambi i casi il flusso verrà distrutto. Questo metodo è diverso dall'ascoltare l'evento `'data'` in quanto utilizza l'evento `readable` nella macchinaria sottostante e può limitare il numero di chiamate fn concorrenti.
isPaused()	Il `readable.isPaused()` metodo restituisce lo stato operativo corrente del `Readable`. Questo è utilizzato principalmente dal meccanismo che sta alla base del `readable.pipe()` metodo. Nella maggior parte dei casi tipici, non ci sarà motivo di utilizzare direttamente questo metodo. `const readable = new stream.Readable(); readable.isPaused(); // === false readable.pause(); readable.isPaused(); // === true readable.resume(); readable.isPaused(); // === false`
iterator(ReadableIteratorOptions)	L'iteratore creato da questo metodo offre agli utenti l'opzione di annullare la distruzione del flusso se il `for await...of` ciclo viene esposto da `return`, `break`, o `throw`se l'iteratore deve distruggere il flusso se il flusso ha emesso un errore durante l'iterazione.
listenerCount(string \| symbol, (args: any[]) => void)
listenerCount<E>(E, (args: ReadableEventMap[E]) => void)	Restituisce il numero di listener in ascolto dell'evento denominato `eventName`. Se viene specificato `listener`, verrà restituito il numero di volte in cui il listener viene trovato nell'elenco dei listener dell'evento.
listeners(string \| symbol)
listeners<E>(E)	Restituisce una copia della matrice di listener per l'evento denominato `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)	Questo metodo consente la mappatura sul flusso. La funzione fn verrà chiamata per ogni blocco del flusso. Se la funzione fn restituisce una promessa, quella promessa sarà `await`ed prima di essere passata al flusso di risultati.
off(string \| symbol, (args: any[]) => void)
off<E>(E, (args: ReadableEventMap[E]) => void)	Alias per `emitter.removeListener()`.
on(string \| symbol, (args: any[]) => void)
on<E>(E, (args: ReadableEventMap[E]) => void)	Aggiunge la funzione `listener` alla fine della matrice listener per l'evento denominato `eventName`. Non vengono effettuati controlli per verificare se il `listener` è già stato aggiunto. Più chiamate che passano la stessa combinazione di `eventName` e `listener` comportano l'aggiunta del `listener` e la chiamata più volte. `server.on('connection', (stream) => { console.log('someone connected!'); });` Restituisce un riferimento alla `EventEmitter`, in modo che le chiamate possano essere concatenati. Per impostazione predefinita, i listener di eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il metodo `emitter.prependListener()` può essere usato come alternativa per aggiungere il listener di eventi all'inizio della matrice di listener. `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)	Aggiunge un funzione di`listener` una tantum per l'evento denominato `eventName`. La volta successiva che viene attivata `eventName`, questo listener viene rimosso e quindi richiamato. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` Restituisce un riferimento alla `EventEmitter`, in modo che le chiamate possano essere concatenati. Per impostazione predefinita, i listener di eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il metodo `emitter.prependOnceListener()` può essere usato come alternativa per aggiungere il listener di eventi all'inizio della matrice di listener. `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()	Il `readable.pause()` metodo farà sì che un flusso in modalità di flusso smetta di emettere `'data'` eventi, passando dalla modalità di scorrenza. Qualsiasi dato che diventi disponibile rimarrà nel 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); }); Il `readable.pause()` metodo non ha effetto se c'è un `'readable'` ascoltatore di eventi.
prependListener(string \| symbol, (args: any[]) => void)
prependListener<E>(E, (args: ReadableEventMap[E]) => void)	Aggiunge la funzione `listener` all'iniziale della matrice listener per l'evento denominato `eventName`. Non vengono effettuati controlli per verificare se il `listener` è già stato aggiunto. Più chiamate che passano la stessa combinazione di `eventName` e `listener` comportano l'aggiunta del `listener` e la chiamata più volte. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` Restituisce un riferimento alla `EventEmitter`, in modo che le chiamate possano essere concatenati.
prependOnceListener(string \| symbol, (args: any[]) => void)
prependOnceListener<E>(E, (args: ReadableEventMap[E]) => void)	Aggiunge una funzione di una tantum per l'evento denominato all'che inizia della matrice listener. Alla successiva attivazione di `eventName`, questo listener viene rimosso e quindi richiamato. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` Restituisce un riferimento alla `EventEmitter`, in modo che le chiamate possano essere concatenati.
push(any, BufferEncoding)
rawListeners(string \| symbol)
rawListeners<E>(E)	Restituisce una copia della matrice di listener per l'evento denominato `eventName`, inclusi tutti i wrapper ( ad esempio quelli creati da `.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)	Il `readable.read()` metodo legge i dati dal buffer interno e li restituisce. Se non sono disponibili dati per la lettura, `null` viene restituito. Per impostazione predefinita, i dati vengono restituiti come `Buffer` oggetto a meno che non sia stata specificata una codifica usando il `readable.setEncoding()` metodo o che il flusso operi in modalità oggetto. L'argomento opzionale `size` specifica un numero specifico di byte da leggere. Se `size` i byte non sono disponibili per la lettura, `null` verranno restituiti a meno che il flusso non sia terminato, nel qual caso tutti i dati rimasti nel buffer interno verranno restituiti. Se l'argomento `size` non viene specificato, tutti i dati contenuti nel buffer interno verranno restituiti. L'argomento `size` deve essere inferiore o uguale a 1 GiB. Il `readable.read()` metodo dovrebbe essere chiamato solo su `Readable` flussi che operano in modalità pausa. In modalità fluida, `readable.read()` viene chiamata automaticamente finché il buffer interno non è completamente esaurito. 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.'); }); Ogni chiamata a `readable.read()` restituisce un blocco di dati, oppure `null`. I chunk non sono concatenati. È necessario un `while` ciclo per consumare tutti i dati attualmente nel buffer. Quando si legge un file `.read()` di grandi dimensioni può restituire `null`, avendo consumato tutto il contenuto bufferizzato finora, ma ci sono ancora altri dati non ancora bufferati. In questo caso verrà emesso un nuovo `'readable'` evento quando ci sono più dati nel buffer. Infine, l'evento `'end'` verrà emesso quando non ci saranno più dati in arrivo. Pertanto, per leggere l'intero contenuto di un file da un `readable`, è necessario raccogliere blocchi su più `'readable'` eventi: `const chunks = []; readable.on('readable', () => { let chunk; while (null !== (chunk = readable.read())) { chunks.push(chunk); } }); readable.on('end', () => { const content = chunks.join(''); });` `Readable` Uno stream in modalità oggetto restituirà sempre un singolo elemento da una chiamata a `readable.read(size)`, indipendentemente dal valore dell'argomento`size`. Se il `readable.read()` metodo restituisce un blocco di dati, verrà emesso anche un `'data'` evento. Chiamando la lettura dopo che l'evento `'end'` è stato emesso restituirà `null`. Non verrà riportato alcun errore di runtime.
reduce<T>((previous: any, data: any, options?: Abortable) => T)	Questo metodo chiama fn su ogni blocco del flusso in ordine, passandogli il risultato del calcolo sull'elemento precedente. Restituisce una promessa per il valore finale della riduzione. Se non viene fornito alcun valore iniziale , il primo blocco del flusso viene utilizzato come valore iniziale. Se il flusso è vuoto, la promessa viene respinta con una `TypeError` con la `ERR_INVALID_ARGS` proprietà di codice. La funzione riduttore itera il flusso elemento per elemento, il che significa che non esiste un parametro di concorrenza o parallelismo. Per eseguire una riduzione simultanea, puoi estrarre la funzione asincrona al `readable.map` metodo.
reduce<T>((previous: T, data: any, options?: Abortable) => T, T, Abortable)
removeAllListeners(string \| symbol)
removeAllListeners<E>(E)	Rimuove tutti i listener o quelli del `eventName`specificato. È consigliabile rimuovere listener aggiunti altrove nel codice, in particolare quando l'istanza di `EventEmitter` è stata creata da un altro componente o modulo (ad esempio socket o flussi di file). Restituisce un riferimento alla `EventEmitter`, in modo che le chiamate possano essere concatenati.
removeListener(string \| symbol, (args: any[]) => void)
removeListener<E>(E, (args: ReadableEventMap[E]) => void)	Rimuove il `listener` specificato dalla matrice di listener per l'evento denominato `eventName`. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` rimuoverà al massimo un'istanza di un listener dalla matrice del listener. Se un listener singolo è stato aggiunto più volte alla matrice di listener per il `eventName`specificato, `removeListener()` deve essere chiamato più volte per rimuovere ogni istanza. Una volta generato un evento, tutti i listener collegati al listener al momento dell'emissione vengono chiamati in ordine. Ciò implica che qualsiasi `removeListener()` chiamata `removeAllListeners()` dopo l'emissione e prima che l'ultimo ascoltatore termini l'esecuzione non le rimuoverà da `emit()` in corso. Gli eventi successivi si comportano come 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 Poiché gli ascoltatori sono gestiti tramite un array interno, chiamare questo aggiornerà gli indici di posizione di qualsiasi ascoltatore registrato dopo che l'ascoltatore sia stato rimosso. Ciò non influirà sull'ordine in cui vengono chiamati i listener, ma significa che tutte le copie della matrice del listener restituite dal metodo `emitter.listeners()` dovranno essere ricreate. Quando una singola funzione è stata aggiunta più volte come gestore per un singolo evento (come nell'esempio seguente), `removeListener()` rimuoverà l'istanza aggiunta più di recente. Nell'esempio il listener `once('ping')` viene rimosso: `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');` Restituisce un riferimento alla `EventEmitter`, in modo che le chiamate possano essere concatenati.
resume()	Il `readable.resume()` metodo fa sì che un flusso esplicitamente `Readable` in pausa riprenda a emettere `'data'` eventi, passando il flusso in modalità fluente. Il `readable.resume()` metodo può essere utilizzato per assorbire completamente i dati di un flusso senza elaborare effettivamente nessuno di quei dati: `getReadableStreamSomehow() .resume() .on('end', () => { console.log('Reached the end, but did not read anything.'); });` Il `readable.resume()` metodo non ha effetto se c'è un `'readable'` ascoltatore di eventi.
setEncoding(BufferEncoding)	Il `readable.setEncoding()` metodo imposta la codifica dei caratteri per i dati letti dal `Readable` flusso. Per impostazione predefinita, non viene assegnata alcuna codifica e i dati del flusso verranno restituiti come `Buffer` oggetti. Impostare una codifica fa sì che i dati del flusso vengano restituiti come stringhe della codifica specificata anziché come `Buffer` oggetti. Ad esempio, chiamare `readable.setEncoding('utf8')` i dati in uscita saranno interpretati come dati UTF-8 e passati come stringhe. Chiamare `readable.setEncoding('hex')` i dati viene codificato in formato di stringa esadecimale. Lo `Readable` stream gestirà correttamente i caratteri multi-byte consegnati attraverso il flusso che altrimenti verrebbero decodificati in modo errato se semplicemente estratti dal flusso come `Buffer` oggetti. `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">)	Questo metodo è simile a `Array.prototype.some` e chiama fn su ogni chunk dello stream fino a quando il valore di ritorno atteso non è `true` (o qualsiasi valore truthy). Una volta che una chiamata fn su un valore di ritorno ed a pezzi `await`è veritiere, il flusso viene distrutto e la promessa viene mantenuta con `true`. Se nessuna delle chiamate di fn restituisce i chunks un valore truthy, la promessa viene mantenuta con `false`.
take(number, Abortable)	Questo metodo restituisce un nuovo flusso con i primi blocchi di limite .
toArray(Abortable)	Questo metodo consente di ottenere facilmente il contenuto di un flusso. Poiché questo metodo legge l'intero flusso in memoria, annulla i benefici dei flusso. È pensato per l'interoperabilità e la comodità, non come il modo principale per consumare stream.
unpipe(WritableStream)	Il `readable.unpipe()` metodo stacca un `Writable` getto precedentemente collegato utilizzando il metodo del tubo . Se il `destination` non è specificato, allora tutti i tubi sono staccati. Se il `destination` metodo è specificato, ma non è previsto alcun tubo per esso, allora il metodo non fa nulla. `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)	Passando `chunk` come `null` segnala la fine del flusso (EOF) e si comporta allo stesso modo di `readable.push(null)`, dopo di che non possono più essere scritti dati. Il segnale EOF viene posizionato alla fine del buffer e qualsiasi dato bufferato verrà comunque svuotato. Il `readable.unshift()` metodo spinge un blocco di dati indietro nel buffer interno. Questo è utile in alcune situazioni in cui uno stream viene consumato da codice che deve "dis-consumare" una certa quantità di dati che ha ottimisticamente estratto dalla sorgente, così che i dati possano essere trasmessi a un'altra parte. Il `stream.unshift(chunk)` metodo non può essere chiamato dopo che l'evento `'end'` è stato emesso, altrimenti verrà generato un errore di runtime. Gli sviluppatori che usano `stream.unshift()` spesso dovrebbero considerare di passare invece a uno `Transform` streaming. Vedi la `API for stream implementers` sezione per maggiori informazioni. // 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 differenza del push, `stream.unshift(chunk)` non interromperà il processo di lettura resettando lo stato interno del flusso di lettura. Questo può causare risultati inaspettati se `readable.unshift()` viene chiamato durante una lettura (cioè dall'interno di una _read implementazione su uno stream personalizzato). Seguire la chiamata con `readable.unshift()` un push immediato azzererà lo stato di lettura in modo appropriato, tuttavia è meglio evitare di chiamare `readable.unshift()` mentre si effettua una lettura.
wrap(ReadableStream)	Prima di Node.js 0.10, gli stream non implementavano l'intera `node:stream` API del modulo come è attualmente definita. (Vedi `Compatibility` per maggiori informazioni.) Quando si utilizza una libreria Node.js più vecchia che emette `'data'` eventi e ha un metodo di pausa solo consultivo, il `readable.wrap()` metodo può essere usato per creare un `Readable` flusso che utilizza il vecchio flusso come fonte dati. Raramente sarà necessario utilizzarlo `readable.wrap()` , ma il metodo è stato fornito come comodità per interagire con applicazioni e librerie Node.js più vecchie. `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]()	Chiama `readable.destroy()` con un `AbortError` e restituisce una promessa che si mantiene quando lo stream è terminato.
[asyncIterator]()
[toAsyncStreamable]()	Quando il `--experimental-stream-iter` flag è abilitato, `Readable` gli stream implementano il `Stream.toAsyncStreamable` protocollo, consentendo un consumo efficiente da parte dell'API `stream/iter` . Questo fornisce un iteratore asincrono batched che drena il buffer interno del flusso in `Uint8Array[]` batch, ammortizzando l'overhead Promise per ogni blocco del percorso standard `Symbol.asyncIterator` . Per i flussi in modalità byte, i chunk vengono forniti direttamente come `Buffer` istanze (che sono `Uint8Array` sottoclassi). Per i flussi in modalità oggetto o codificati, ogni chunk viene normalizzato a `Uint8Array` prima del batching. L'iteratore restituito viene etichettato come sorgente validata, quindi `from()` lo passa senza ulteriore normalizzazione. `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'` Senza la `--experimental-stream-iter` bandiera, chiamare questo metodo genera `ERR_STREAM_ITER_MISSING_FLAG`.

Metodi ereditati

eventNames()	Restituisce una matrice che elenca gli eventi per i quali l'emettitore ha registrato listener. `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()	Restituisce il valore massimo del listener corrente per il `EventEmitter` impostato da `emitter.setMaxListeners(n)` o per impostazione predefinita su `events.defaultMaxListeners`.
pipe<T>(T, PipeOptions)
setMaxListeners(number)	Per impostazione predefinita, `EventEmitter`s visualizzerà un avviso se vengono aggiunti più di `10` listener per un determinato evento. Si tratta di un valore predefinito utile che consente di trovare perdite di memoria. Il metodo `emitter.setMaxListeners()` consente di modificare il limite per questa specifica istanza di `EventEmitter`. Il valore può essere impostato su `Infinity` (o `0`) per indicare un numero illimitato di listener. Restituisce un riferimento alla `EventEmitter`, in modo che le chiamate possano essere concatenati.
[captureRejectionSymbol](Error, string \| symbol, any[])	Il `Symbol.for('nodejs.rejection')` metodo viene chiamato nel caso in cui si verifichi un rifiuto di promessa durante l'emissione di un evento ed `captureRejections` è abilitato sull'emettitore. È possibile usarla `events.captureRejectionSymbol` al posto di `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. } }`

Dettagli proprietà

closed

È true dopo 'close' che è stato emesso.

closed: boolean

Valore della proprietà

boolean

destroyed

È true dopo readable.destroy() che è stato chiamato.

destroyed: boolean

Valore della proprietà

boolean

errored

Restituisce errore se il flusso è stato distrutto con un errore.

errored: Error | null

Valore della proprietà

Error | null

readable

È true se è sicuro chiamare read, il che significa che il flusso non è stato distrutto o emesso 'error' o 'end'.

readable: boolean

Valore della proprietà

boolean

readableAborted

Restituisce se il flusso è stato distrutto o ha commesso un errore prima di emettere 'end'.

readableAborted: boolean

Valore della proprietà

boolean

readableDidRead

Restituisce se 'data' è stato emesso.

readableDidRead: boolean

Valore della proprietà

boolean

readableEncoding

Getter per la proprietà encoding di un dato Readable ruscello. La encoding proprietà può essere impostata usando il metodo setEncoding .

readableEncoding: BufferEncoding | null

Valore della proprietà

BufferEncoding | null

readableEnded

Diventa true quando 'end' viene emesso un evento.

readableEnded: boolean

Valore della proprietà

boolean

readableFlowing

Questa proprietà riflette lo stato attuale di un Readable corso d'acqua come descritto nella sezione dei Tre stati .

readableFlowing: boolean | null

Valore della proprietà

boolean | null

readableHighWaterMark

Restituisce il valore di highWaterMark passato quando si crea questo Readable.

readableHighWaterMark: number

Valore della proprietà

number

readableLength

Questa proprietà contiene il numero di byte (o oggetti) nella coda pronti per essere letti. Il valore fornisce dati di introspezione riguardanti lo highWaterMarkstato del .

readableLength: number

Valore della proprietà

number

readableObjectMode

Getter per la proprietà objectMode di un dato Readable ruscello.

readableObjectMode: boolean

Valore della proprietà

boolean

Dettagli metodo

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

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

Parametri

eventName: string | symbol

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

Valori restituiti

this

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

Alias per emitter.on(eventName, listener).

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

Parametri

eventName: E

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

Valori restituiti

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

Questo metodo consente anche di fornire un AbortSignal , che distruggerà il flusso composto se abortito.

Per altre informazioni, vedere stream.compose(...streams).

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

Parametri

stream: WritableStream | WritableStream | TransformStream | (source: any) => void

options: Abortable

Valori restituiti

Duplex

un flusso composto dal flusso stream.

destroy(Error)

Distruggi il flusso. Opzionalmente emetti un 'error' evento e un 'close' evento (a meno che emitClose non sia impostato su false). Dopo questa chiamata, il flusso leggibile rilascia tutte le risorse interne e le chiamate successive push() verranno ignorate.

Una volta destroy() chiamata, eventuali ulteriori chiamate saranno no-op e non possono essere emessi _destroy()altri errori tranne da 'error' .

Gli implementatori non dovrebbero sovrascrivere questo metodo, ma implementare readable._destroy()invece .

function destroy(error?: Error): this

Parametri

error: Error

Errore che verrà passato come payload in 'error' caso

Valori restituiti

this

drop(number, Abortable)

Questo metodo restituisce un nuovo flusso con i primi blocchi di limite eliminati dall'inizio.

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

Parametri

limit: number

il numero di blocchi da eliminare dal leggibile.

options: Abortable

Valori restituiti

Readable

un flusso con i blocchi limite eliminati dall'inizio.

emit(string | symbol, any[])

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

Parametri

eventName: string | symbol

args: any[]

Valori restituiti

boolean

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

Chiama in modo sincrono ogni listener registrato per l'evento denominato eventName, nell'ordine in cui sono stati registrati, passando gli argomenti forniti a ognuno.

Restituisce true se l'evento include listener, false in caso 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

Parametri

eventName: E

args: ReadableEventMap[E]

Valori restituiti

boolean

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

Questo metodo è simile a Array.prototype.every and calls fn su ogni chunk dello stream per verificare se tutti i valori di ritorno attesi siano veri valori per fn. Una volta che una chiamata fn su un valore di ritorno ed a chunk awaitè falsa, il flusso viene distrutto e la promessa viene mantenuta con false. Se tutte le chiamate fn sui chunks restituiscono un valore truthy, la promessa viene mantenuta con true.

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

Parametri

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

una funzione per chiamare ogni blocco del flusso. Asincrono o no.

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

Valori restituiti

Promise<boolean>

Una promessa che valuta se trueFN restituisse un valore truthy per ciascuno dei blocchi.

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

Questo metodo permette di filtrare il flusso. Per ogni chunk del flusso verrà chiamata la funzione fn e se restituisce un valore truthy, il chunk verrà passato al flusso risultato. Se la funzione fn restituisce una promessa, quella promessa sarà awaited.

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

Parametri

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

una funzione per filtrare i blocchi dal flusso. Asincrono o no.

options: ReadableOperatorOptions

Valori restituiti

Readable

un flusso filtrato con il predicato 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>

Parametri

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

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

Valori restituiti

Promise<any>

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

Questo metodo è simile a Array.prototype.find e chiama fn su ogni chunk del flusso per trovare un chunk con un valore truthy per fn. Una volta che il valore atteso di ritorno di una chiamata fn è truthy, lo stream viene distrutto e la promessa viene mantenuta con un valore per il quale fn ha restituito un valore truthy. Se tutte le chiamate fn sui chunks restituiscono un valore falso, la promessa viene mantenuta con undefined.

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

Parametri

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

una funzione per chiamare ogni blocco del flusso. Asincrono o no.

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

Valori restituiti

Promise<T | undefined>

una promessa che valuta fino al primo blocco per cui FN valutato con un valore truthy, o undefined se non è stato trovato alcun elemento.

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

Questo metodo restituisce un nuovo flusso applicando il callback dato a ogni blocco del flusso e poi appiattendo il risultato.

È possibile restituire uno stream o un altro iterabile o asincrono da fn e i flussi risultanti verranno uniti (appiattiti) nel flusso restituito.

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

Parametri

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

una funzione per mappare ogni blocco del flusso. Potrebbe essere asincrono. Potrebbe essere un getto o un generatore.

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

Valori restituiti

Readable

un flusso flat-mapped con la funzione fn.

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

Questo metodo permette di iterare un flusso. Per ogni chunk del flusso verrà chiamata la funzione fn . Se la funzione fn restituisce una promessa, quella promessa sarà awaited.

Questo metodo è diverso dai for await...of loop in quanto può opzionalmente elaborare i chunk contemporaneamente. Inoltre, un'iterazione forEach può essere fermata solo avendo superato un'opzione signal e abortendo l'AbortController correlato mentre for await...of può essere fermata con break o return. In entrambi i casi il flusso verrà distrutto.

Questo metodo è diverso dall'ascoltare l'evento 'data' in quanto utilizza l'evento readable nella macchinaria sottostante e può limitare il numero di chiamate fn concorrenti.

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

Parametri

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

una funzione per chiamare ogni blocco del flusso. Asincrono o no.

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

Valori restituiti

Promise<void>

una promessa per quando la diretta sarà finita.

isPaused()

Il readable.isPaused() metodo restituisce lo stato operativo corrente del Readable. Questo è utilizzato principalmente dal meccanismo che sta alla base del readable.pipe() metodo. Nella maggior parte dei casi tipici, non ci sarà motivo di utilizzare direttamente questo metodo.

const readable = new stream.Readable();

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

function isPaused(): boolean

Valori restituiti

boolean

iterator(ReadableIteratorOptions)

L'iteratore creato da questo metodo offre agli utenti l'opzione di annullare la distruzione del flusso se il for await...of ciclo viene esposto da return, break, o throwse l'iteratore deve distruggere il flusso se il flusso ha emesso un errore durante l'iterazione.

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

Parametri

options: ReadableIteratorOptions

Valori restituiti

AsyncIterator<any>

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

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

Parametri

eventName: string | symbol

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

Valori restituiti

number

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

Restituisce il numero di listener in ascolto dell'evento denominato eventName. Se viene specificato listener, verrà restituito il numero di volte in cui il listener viene trovato nell'elenco dei listener dell'evento.

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

Parametri

eventName: E

Nome dell'evento in ascolto

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

Funzione del gestore eventi

Valori restituiti

number

listeners(string | symbol)

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

Parametri

eventName: string | symbol

Valori restituiti

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

listeners<E>(E)

Restituisce una copia della matrice di listener per l'evento denominato 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[]

Parametri

eventName: E

Valori restituiti

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

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

Questo metodo consente la mappatura sul flusso. La funzione fn verrà chiamata per ogni blocco del flusso. Se la funzione fn restituisce una promessa, quella promessa sarà awaited prima di essere passata al flusso di risultati.

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

Parametri

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

una funzione per mappare ogni blocco del flusso. Asincrono o no.

options: ReadableOperatorOptions

Valori restituiti

Readable

un flusso mappato con la funzione fn.

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

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

Parametri

eventName: string | symbol

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

Valori restituiti

this

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

Alias per emitter.removeListener().

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

Parametri

eventName: E

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

Valori restituiti

this

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

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

Parametri

eventName: string | symbol

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

Valori restituiti

this

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

Aggiunge la funzione listener alla fine della matrice listener per l'evento denominato eventName. Non vengono effettuati controlli per verificare se il listener è già stato aggiunto. Più chiamate che passano la stessa combinazione di eventName e listener comportano l'aggiunta del listener e la chiamata più volte.

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

Restituisce un riferimento alla EventEmitter, in modo che le chiamate possano essere concatenati.

Per impostazione predefinita, i listener di eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il metodo emitter.prependListener() può essere usato come alternativa per aggiungere il listener di eventi all'inizio della matrice di listener.

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

Parametri

eventName: E

Nome dell'evento.

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

Funzione di callback

Valori restituiti

this

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

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

Parametri

eventName: string | symbol

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

Valori restituiti

this

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

Aggiunge un funzione dilistener una tantum per l'evento denominato eventName. La volta successiva che viene attivata eventName, questo listener viene rimosso e quindi richiamato.

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

Restituisce un riferimento alla EventEmitter, in modo che le chiamate possano essere concatenati.

Per impostazione predefinita, i listener di eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il metodo emitter.prependOnceListener() può essere usato come alternativa per aggiungere il listener di eventi all'inizio della matrice di listener.

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

Parametri

eventName: E

Nome dell'evento.

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

Funzione di callback

Valori restituiti

this

pause()

Il readable.pause() metodo farà sì che un flusso in modalità di flusso smetta di emettere 'data' eventi, passando dalla modalità di scorrenza. Qualsiasi dato che diventi disponibile rimarrà nel 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);
});

Il readable.pause() metodo non ha effetto se c'è un 'readable' ascoltatore di eventi.

function pause(): this

Valori restituiti

this

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

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

Parametri

eventName: string | symbol

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

Valori restituiti

this

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

Aggiunge la funzione listener all'iniziale della matrice listener per l'evento denominato eventName. Non vengono effettuati controlli per verificare se il listener è già stato aggiunto. Più chiamate che passano la stessa combinazione di eventName e listener comportano l'aggiunta del listener e la chiamata più volte.

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

Restituisce un riferimento alla EventEmitter, in modo che le chiamate possano essere concatenati.

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

Parametri

eventName: E

Nome dell'evento.

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

Funzione di callback

Valori restituiti

this

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

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

Parametri

eventName: string | symbol

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

Valori restituiti

this

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

Aggiunge una funzione di una tantum per l'evento denominato all'che inizia della matrice listener. Alla successiva attivazione di eventName, questo listener viene rimosso e quindi richiamato.

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

Restituisce un riferimento alla EventEmitter, in modo che le chiamate possano essere concatenati.

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

Parametri

eventName: E

Nome dell'evento.

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

Funzione di callback

Valori restituiti

this

push(any, BufferEncoding)

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

Parametri

chunk: any

encoding: BufferEncoding

Valori restituiti

boolean

rawListeners(string | symbol)

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

Parametri

eventName: string | symbol

Valori restituiti

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

rawListeners<E>(E)

Restituisce una copia della matrice di listener per l'evento denominato eventName, inclusi tutti i wrapper ( ad esempio quelli creati da .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[]

Parametri

eventName: E

Valori restituiti

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

read(number)

Il readable.read() metodo legge i dati dal buffer interno e li restituisce. Se non sono disponibili dati per la lettura, null viene restituito. Per impostazione predefinita, i dati vengono restituiti come Buffer oggetto a meno che non sia stata specificata una codifica usando il readable.setEncoding() metodo o che il flusso operi in modalità oggetto.

L'argomento opzionale size specifica un numero specifico di byte da leggere. Se size i byte non sono disponibili per la lettura, null verranno restituiti a meno che il flusso non sia terminato, nel qual caso tutti i dati rimasti nel buffer interno verranno restituiti.

Se l'argomento size non viene specificato, tutti i dati contenuti nel buffer interno verranno restituiti.

L'argomento size deve essere inferiore o uguale a 1 GiB.

Il readable.read() metodo dovrebbe essere chiamato solo su Readable flussi che operano in modalità pausa. In modalità fluida, readable.read() viene chiamata automaticamente finché il buffer interno non è completamente esaurito.

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

Ogni chiamata a readable.read() restituisce un blocco di dati, oppure null. I chunk non sono concatenati. È necessario un while ciclo per consumare tutti i dati attualmente nel buffer. Quando si legge un file .read() di grandi dimensioni può restituire null, avendo consumato tutto il contenuto bufferizzato finora, ma ci sono ancora altri dati non ancora bufferati. In questo caso verrà emesso un nuovo 'readable' evento quando ci sono più dati nel buffer. Infine, l'evento 'end' verrà emesso quando non ci saranno più dati in arrivo.

Pertanto, per leggere l'intero contenuto di un file da un readable, è necessario raccogliere blocchi su più 'readable' eventi:

const chunks = [];

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

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

Readable Uno stream in modalità oggetto restituirà sempre un singolo elemento da una chiamata a readable.read(size), indipendentemente dal valore dell'argomentosize.

Se il readable.read() metodo restituisce un blocco di dati, verrà emesso anche un 'data' evento.

Chiamando la lettura dopo che l'evento 'end' è stato emesso restituirà null. Non verrà riportato alcun errore di runtime.

function read(size?: number): any

Parametri

size: number

Argomento opzionale per specificare quanti dati leggere.

Valori restituiti

any

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

Questo metodo chiama fn su ogni blocco del flusso in ordine, passandogli il risultato del calcolo sull'elemento precedente. Restituisce una promessa per il valore finale della riduzione.

Se non viene fornito alcun valore iniziale , il primo blocco del flusso viene utilizzato come valore iniziale. Se il flusso è vuoto, la promessa viene respinta con una TypeError con la ERR_INVALID_ARGS proprietà di codice.

La funzione riduttore itera il flusso elemento per elemento, il che significa che non esiste un parametro di concorrenza o parallelismo. Per eseguire una riduzione simultanea, puoi estrarre la funzione asincrona al readable.map metodo.

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

Parametri

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

una funzione riduttore per richiamare ogni blocco nel flusso. Asincrono o no.

Valori restituiti

Promise<T>

una promessa per il valore finale della riduzione.

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>

Parametri

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

initial: T

options: Abortable

Valori restituiti

Promise<T>

removeAllListeners(string | symbol)

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

Parametri

eventName: string | symbol

Valori restituiti

this

removeAllListeners<E>(E)

Rimuove tutti i listener o quelli del eventNamespecificato.

È consigliabile rimuovere listener aggiunti altrove nel codice, in particolare quando l'istanza di EventEmitter è stata creata da un altro componente o modulo (ad esempio socket o flussi di file).

Restituisce un riferimento alla EventEmitter, in modo che le chiamate possano essere concatenati.

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

Parametri

eventName: E

Valori restituiti

this

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

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

Parametri

eventName: string | symbol

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

Valori restituiti

this

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

Rimuove il listener specificato dalla matrice di listener per l'evento denominato eventName.

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

removeListener() rimuoverà al massimo un'istanza di un listener dalla matrice del listener. Se un listener singolo è stato aggiunto più volte alla matrice di listener per il eventNamespecificato, removeListener() deve essere chiamato più volte per rimuovere ogni istanza.

Una volta generato un evento, tutti i listener collegati al listener al momento dell'emissione vengono chiamati in ordine. Ciò implica che qualsiasi removeListener() chiamata removeAllListeners() dopo l'emissione e prima che l'ultimo ascoltatore termini l'esecuzione non le rimuoverà da emit() in corso. Gli eventi successivi si comportano come 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

Poiché gli ascoltatori sono gestiti tramite un array interno, chiamare questo aggiornerà gli indici di posizione di qualsiasi ascoltatore registrato dopo che l'ascoltatore sia stato rimosso. Ciò non influirà sull'ordine in cui vengono chiamati i listener, ma significa che tutte le copie della matrice del listener restituite dal metodo emitter.listeners() dovranno essere ricreate.

Quando una singola funzione è stata aggiunta più volte come gestore per un singolo evento (come nell'esempio seguente), removeListener() rimuoverà l'istanza aggiunta più di recente. Nell'esempio il listener once('ping') viene rimosso:

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

Restituisce un riferimento alla EventEmitter, in modo che le chiamate possano essere concatenati.

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

Parametri

eventName: E

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

Valori restituiti

this

resume()

Il readable.resume() metodo fa sì che un flusso esplicitamente Readable in pausa riprenda a emettere 'data' eventi, passando il flusso in modalità fluente.

Il readable.resume() metodo può essere utilizzato per assorbire completamente i dati di un flusso senza elaborare effettivamente nessuno di quei dati:

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

Il readable.resume() metodo non ha effetto se c'è un 'readable' ascoltatore di eventi.

function resume(): this

Valori restituiti

this

setEncoding(BufferEncoding)

Il readable.setEncoding() metodo imposta la codifica dei caratteri per i dati letti dal Readable flusso.

Per impostazione predefinita, non viene assegnata alcuna codifica e i dati del flusso verranno restituiti come Buffer oggetti. Impostare una codifica fa sì che i dati del flusso vengano restituiti come stringhe della codifica specificata anziché come Buffer oggetti. Ad esempio, chiamare readable.setEncoding('utf8') i dati in uscita saranno interpretati come dati UTF-8 e passati come stringhe. Chiamare readable.setEncoding('hex') i dati viene codificato in formato di stringa esadecimale.

Lo Readable stream gestirà correttamente i caratteri multi-byte consegnati attraverso il flusso che altrimenti verrebbero decodificati in modo errato se semplicemente estratti dal flusso come Buffer oggetti.

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

Parametri

encoding: BufferEncoding

Codifica da usare.

Valori restituiti

this

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

Questo metodo è simile a Array.prototype.some e chiama fn su ogni chunk dello stream fino a quando il valore di ritorno atteso non è true (o qualsiasi valore truthy). Una volta che una chiamata fn su un valore di ritorno ed a pezzi awaitè veritiere, il flusso viene distrutto e la promessa viene mantenuta con true. Se nessuna delle chiamate di fn restituisce i chunks un valore truthy, la promessa viene mantenuta con false.

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

Parametri

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

una funzione per chiamare ogni blocco del flusso. Asincrono o no.

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

Valori restituiti

Promise<boolean>

Una promessa che valuta se trueFN ha restituito un valore truthy per almeno uno dei blocchi.

take(number, Abortable)

Questo metodo restituisce un nuovo flusso con i primi blocchi di limite .

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

Parametri

limit: number

il numero di blocchi da prendere dal leggibili.

options: Abortable

Valori restituiti

Readable

Un flusso con i blocchi limite occupati.

toArray(Abortable)

Questo metodo consente di ottenere facilmente il contenuto di un flusso.

Poiché questo metodo legge l'intero flusso in memoria, annulla i benefici dei flusso. È pensato per l'interoperabilità e la comodità, non come il modo principale per consumare stream.

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

Parametri

options: Abortable

Valori restituiti

Promise<any[]>

una promessa contenente un array con il contenuto del flusso.

unpipe(WritableStream)

Il readable.unpipe() metodo stacca un Writable getto precedentemente collegato utilizzando il metodo del tubo .

Se il destination non è specificato, allora tutti i tubi sono staccati.

Se il destination metodo è specificato, ma non è previsto alcun tubo per esso, allora il metodo non fa nulla.

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

Parametri

destination: WritableStream

Flusso specifico opzionale per unpipe

Valori restituiti

this

unshift(any, BufferEncoding)

Passando chunk come null segnala la fine del flusso (EOF) e si comporta allo stesso modo di readable.push(null), dopo di che non possono più essere scritti dati. Il segnale EOF viene posizionato alla fine del buffer e qualsiasi dato bufferato verrà comunque svuotato.

Il readable.unshift() metodo spinge un blocco di dati indietro nel buffer interno. Questo è utile in alcune situazioni in cui uno stream viene consumato da codice che deve "dis-consumare" una certa quantità di dati che ha ottimisticamente estratto dalla sorgente, così che i dati possano essere trasmessi a un'altra parte.

Il stream.unshift(chunk) metodo non può essere chiamato dopo che l'evento 'end' è stato emesso, altrimenti verrà generato un errore di runtime.

Gli sviluppatori che usano stream.unshift() spesso dovrebbero considerare di passare invece a uno Transform streaming. Vedi la API for stream implementers sezione per maggiori informazioni.

// 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 differenza del push, stream.unshift(chunk) non interromperà il processo di lettura resettando lo stato interno del flusso di lettura. Questo può causare risultati inaspettati se readable.unshift() viene chiamato durante una lettura (cioè dall'interno di una _read implementazione su uno stream personalizzato). Seguire la chiamata con readable.unshift() un push immediato azzererà lo stato di lettura in modo appropriato, tuttavia è meglio evitare di chiamare readable.unshift() mentre si effettua una lettura.

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

Parametri

chunk: any

Un blocco di dati da spostare sulla coda di lettura. Per i flussi che non operano in modalità oggetto, chunk devono essere una {string}, {Buffer}, {TypedArray}, {DataView} o null. Per i flussi in modalità oggetto, chunk può essere qualsiasi valore JavaScript.

encoding: BufferEncoding

Codifica dei blocchi di stringa. Deve essere una codifica valida Buffer , come 'utf8' o 'ascii'.

wrap(ReadableStream)

Prima di Node.js 0.10, gli stream non implementavano l'intera node:stream API del modulo come è attualmente definita. (Vedi Compatibility per maggiori informazioni.)

Quando si utilizza una libreria Node.js più vecchia che emette 'data' eventi e ha un metodo di pausa solo consultivo, il readable.wrap() metodo può essere usato per creare un Readable flusso che utilizza il vecchio flusso come fonte dati.

Raramente sarà necessario utilizzarlo readable.wrap() , ma il metodo è stato fornito come comodità per interagire con applicazioni e librerie Node.js più vecchie.

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

Parametri

stream: ReadableStream

Un flusso "vecchio stile" leggibile

Valori restituiti

this

[asyncDispose]()

Chiama readable.destroy() con un AbortError e restituisce una promessa che si mantiene quando lo stream è terminato.

function [asyncDispose](): Promise<void>

Valori restituiti

Promise<void>

[asyncIterator]()

function [asyncIterator](): AsyncIterator<any>

Valori restituiti

AsyncIterator<any>

AsyncIterator per consumare completamente il getto.

[toAsyncStreamable]()

Quando il --experimental-stream-iter flag è abilitato, Readable gli stream implementano il Stream.toAsyncStreamable protocollo, consentendo un consumo efficiente da parte dell'API stream/iter .

Questo fornisce un iteratore asincrono batched che drena il buffer interno del flusso in Uint8Array[] batch, ammortizzando l'overhead Promise per ogni blocco del percorso standard Symbol.asyncIterator . Per i flussi in modalità byte, i chunk vengono forniti direttamente come Buffer istanze (che sono Uint8Array sottoclassi). Per i flussi in modalità oggetto o codificati, ogni chunk viene normalizzato a Uint8Array prima del batching.

L'iteratore restituito viene etichettato come sorgente validata, quindi from() lo passa senza ulteriore normalizzazione.

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'

Senza la --experimental-stream-iter bandiera, chiamare questo metodo genera ERR_STREAM_ITER_MISSING_FLAG.

function [toAsyncStreamable](): ByteReadableStream

Valori restituiti

ByteReadableStream

Dettagli dei metodi ereditati

eventNames()

Restituisce una matrice che elenca gli eventi per i quali l'emettitore ha registrato listener.

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

Valori restituiti

(string | symbol)[]

Ereditato da Stream.eventNames

getMaxListeners()

Restituisce il valore massimo del listener corrente per il EventEmitter impostato da emitter.setMaxListeners(n) o per impostazione predefinita su events.defaultMaxListeners.

function getMaxListeners(): number

Valori restituiti

number

Ereditato da Stream.getMaxListeners

pipe<T>(T, PipeOptions)

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

Parametri

destination: T

options: PipeOptions

Valori restituiti

Ereditato da Stream.pipe

setMaxListeners(number)

Per impostazione predefinita, EventEmitters visualizzerà un avviso se vengono aggiunti più di 10 listener per un determinato evento. Si tratta di un valore predefinito utile che consente di trovare perdite di memoria. Il metodo emitter.setMaxListeners() consente di modificare il limite per questa specifica istanza di EventEmitter. Il valore può essere impostato su Infinity (o 0) per indicare un numero illimitato di listener.

Restituisce un riferimento alla EventEmitter, in modo che le chiamate possano essere concatenati.

function setMaxListeners(n: number): this

Parametri

n: number

Valori restituiti

this

Ereditato da Stream.setMaxAscoltatori

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

Il Symbol.for('nodejs.rejection') metodo viene chiamato nel caso in cui si verifichi un rifiuto di promessa durante l'emissione di un evento ed captureRejections è abilitato sull'emettitore. È possibile usarla events.captureRejectionSymbol al posto di 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[])

Parametri

error: Error

event: string | symbol

args: any[]

Ereditato da Stream. [catturaSimboloRifiuto]