Readable class

new Readable(options?: ReadableOptions<Readable>)

Parametri

È true dopo 'close' che è stato emesso.

closed: boolean

Valore della proprietà

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

destroyed: boolean

Valore della proprietà

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

errored: null | Error

Valore della proprietà

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

readable: boolean

Valore della proprietà

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

readableAborted: boolean

Valore della proprietà

Restituisce se 'data' è stato emesso.

readableDidRead: boolean

Valore della proprietà

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

readableEncoding: null | BufferEncoding

Valore della proprietà

Diventa true quando 'end' viene emesso un evento.

readableEnded: boolean

Valore della proprietà

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

readableFlowing: null | boolean

Valore della proprietà

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

readableHighWaterMark: number

Valore della proprietà

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à

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

readableObjectMode: boolean

Valore della proprietà

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

un flusso composto dal flusso stream.

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 'error'altri errori tranne da _destroy() .

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

function destroy(error?: Error): Readable

Parametri

Valori restituiti

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

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

Parametri

Valori restituiti

un flusso con i blocchi limite eliminati dall'inizio.

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

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

Valori restituiti

un flusso filtrato con il predicato fn.

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

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

Parametri

Valori restituiti

un flusso flat-mapped con la funzione fn.

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

Parametri

Valori restituiti

una promessa per quando la diretta sarà finita.

Un metodo di utilità per creare flussi leggibili da iteratori.

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

Parametri

Valori restituiti

Un metodo di utilità per creare un Readable da un web ReadableStream.

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

Parametri

Valori restituiti

Restituisce sia che lo stream sia stato letto o cancellato.

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

Parametri

Valori restituiti

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

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, undefined, any>

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Valori restituiti

un flusso mappato con la funzione fn.

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Valori restituiti

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

Valori restituiti

una promessa per il valore finale della riduzione.

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

Valori restituiti

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

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

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

Parametri

Valori restituiti

Un flusso con i blocchi limite occupati.

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

Valori restituiti

una promessa contenente un array con il contenuto del flusso.

Un metodo di utilità per creare una rete ReadableStream da un Readable.

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

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

Parametri

Valori restituiti

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

Valori restituiti

AsyncIterator per consumare completamente il getto.

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

Ereditato da Stream.eventNames

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

Ereditato da Stream.getMaxListeners

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

Parametri

Valori restituiti

Ereditato da Stream.pipe

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

Parametri

Valori restituiti

Ereditato da Stream.setMaxAscoltatori

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

Ereditato da Stream.__@captureRejectionSymbol@175