Client class

Valore: booleano

Cambia l'opzione predefinita captureRejections su tutti i nuovi EventEmitter oggetti.

static captureRejections: boolean

Valore della proprietà

Ereditato da EventEmitter.catturaRejections

Valore: Symbol.for('nodejs.rejection')

Vedi come scrivere un file personalizzato rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valore della proprietà

Ereditato da EventEmitter.captureRejectionSymbol.

Per impostazione predefinita, un massimo di 10 ascoltatori può essere registrato per un singolo evento. Questo limite può essere modificato per singole EventEmitter istanze utilizzando il emitter.setMaxListeners(n) metodo. Per cambiare il valore predefinito per tutteEventEmitter le istanze, si può utilizzare la events.defaultMaxListeners proprietà. Se questo valore non è un numero positivo, si lancia a RangeError .

Fai attenzione quando imposti il events.defaultMaxListeners cambiamento perché la modifica riguarda tutteEventEmitter le istanze, comprese quelle create prima che la modifica venga effettuata. Tuttavia, chiamare emitter.setMaxListeners(n) ha ancora precedenza su events.defaultMaxListeners.

Non è un limite rigido. L'istanza EventEmitter permetterà di aggiungere più ascoltatori ma invierà un avviso di traccia a stderr che indica che è stata rilevata una "possibile perdita di memoria EventEmitter". Per ogni singolo EventEmitter, i emitter.getMaxListeners() metodi e emitter.setMaxListeners() possono essere usati per evitare temporaneamente questo avvertimento:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

Il --trace-warnings flag della riga di comando può essere usato per visualizzare la traccia dello stack per tali avvisi.

L'avviso emesso può essere ispezionato con process.on('warning') e avrà le proprietà aggiuntive emitter, type, e count che si riferiscono rispettivamente all'istanza dell'emettitore dell'evento, al nome dell'evento e al numero di ascoltatori collegati. La sua proprietà è impostata name a 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valore della proprietà

Ereditato da EventEmitter.defaultMaxListeners

Questo simbolo deve essere utilizzato per installare un ascoltatore solo per il monitoraggio 'error' degli eventi. Gli ascoltatori installati con questo simbolo vengono chiamati prima che vengano chiamati gli ascoltatori regolari 'error' .

L'installazione di un listener usando questo simbolo non cambia il comportamento una volta che un 'error' evento viene emesso. Pertanto, il processo continuerà a crashare se non viene installato un ascoltatore regolare 'error' .

static errorMonitor: typeof errorMonitor

Valore della proprietà

Ereditato da EventEmitter.errorMonitor

function close(): Promise<ResultWithIncomingMessage<Disconnected>>

Valori restituiti

Chiude la connessione a un hub IoT.

function close(done?: IncomingMessageCallback<Disconnected>)

Parametri

Crea un client del servizio hub IoT dalla stringa di connessione specificata usando il trasporto predefinito (Amqp) o quello specificato nel secondo argomento.

static function fromConnectionString(connStr: string, transportCtor?: TransportCtor): Client

Parametri

Valori restituiti

Crea un client del servizio hub IoT dalla firma di accesso condiviso specificata usando il trasporto predefinito (Amqp) o quello specificato nel secondo argomento.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor?: TransportCtor): Client

Parametri

Valori restituiti

Crea un client del servizio hub IoT dal token di Azure specificatoCredential usando il trasporto predefinito (Amqp) o quello specificato nel secondo argomento.

static function fromTokenCredential(hostName: string, tokenCredential: TokenCredential, transportCtor?: TransportCtor): Client

Parametri

Valori restituiti

function getFeedbackReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

Valori restituiti

Restituisce un oggetto AmqpReceiver che genera eventi quando vengono ricevuti nuovi messaggi di feedback dal client.

function getFeedbackReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Parametri

function getFileNotificationReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

Valori restituiti

Restituisce un oggetto AmqpReceiver che genera eventi quando vengono ricevute dal client nuove notifiche di caricamento di file.

function getFileNotificationReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Parametri

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

Parametri

Valori restituiti

Richiama un metodo in un determinato dispositivo o modulo.

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams, done?: IncomingMessageCallback<any>)

Parametri

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

Parametri

Valori restituiti

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams, done: IncomingMessageCallback<any>)

Parametri

function open(): Promise<ResultWithIncomingMessage<Connected>>

Valori restituiti

Apre la connessione a un hub IoT.

function open(done?: IncomingMessageCallback<Connected>)

Parametri

function send(deviceId: string, message: Message | BufferConvertible): Promise<ResultWithIncomingMessage<MessageEnqueued>>

Parametri

Valori restituiti

Invia un messaggio a un dispositivo.

function send(deviceId: string, message: Message | BufferConvertible, done?: IncomingMessageCallback<MessageEnqueued>)

Parametri

Impostare i criteri usati dal client per ripetere le operazioni di rete.

function setRetryPolicy(policy: RetryPolicy)

Parametri

Ascolta una volta l'evento abort sul sito fornito signal.

Ascoltare l'evento abort sui segnali di aborto è pericoloso e può portare a perdite di risorse poiché un'altra terza parte con il segnale può chiamare e.stopImmediatePropagation(). Purtroppo Node.js non posso cambiare questo perché violerebbe lo standard web. Inoltre, l'API originale rende facile dimenticare di rimuovere gli ascoltatori.

Questa API consente l'uso AbortSignalsicuro di s in Node.js API risolvendo questi due problemi ascoltando l'evento in modo da stopImmediatePropagation non impedire all'ascoltatore di eseguirlo.

Restituisce un usa e getta così da poter essere cancellato più facilmente.

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}

static function addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable

Parametri

Valori restituiti

Usa e getta che toglie l'ascoltatore abort .

Ereditato da EventEmitter.addAbortListener

Alias per emitter.on(eventName, listener).

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

Parametri

Valori restituiti

Ereditato da EventEmitter.addListener

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<K>(eventName: string | symbol, args: AnyRest): boolean

Parametri

Valori restituiti

Ereditato da EventEmitter.emit

Restituisce una matrice che elenca gli eventi per i quali l'emettitore ha registrato listener. I valori nella matrice sono stringhe o Symbols.

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 EventEmitter.eventNames

Restituisce una copia della matrice di listener per l'evento denominato eventName.

Per EventEmitters questo si comporta esattamente come chiamare .listeners l'emettitore.

Per EventTargets questo è l'unico modo per ottenere gli ascoltatori dell'evento per il target dell'evento. Questo è utile per scopi di debug e diagnostica.

import { getEventListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget, name: string | symbol): Function[]

Parametri

Valori restituiti

Ereditato da EventEmitter.getEventListeners

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

function getMaxListeners(): number

Valori restituiti

ereditato da EventEmitter.getMaxListeners

Restituisce il numero massimo di ascoltatori attualmente impostato.

Per EventEmitters questo si comporta esattamente come chiamare .getMaxListeners l'emettitore.

Per EventTargets questo è l'unico modo per ottenere il massimo ascolto di eventi per il target dell'evento. Se il numero di gestori di eventi su un singolo EventTarget supera il set massimo, l'EventTarget stamperà un avviso.

import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}

static function getMaxListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget): number

Parametri

Valori restituiti

ereditato da EventEmitter.getMaxListeners

Un metodo di classe che restituisce il numero di ascoltatori per il dato eventName registrato sul dato emitter.

import { EventEmitter, listenerCount } from 'node:events';

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

static function listenerCount(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol): number

Parametri

Valori restituiti

Ereditato da EventEmitter.listenerCount

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<K>(eventName: string | symbol, listener?: Function): number

Parametri

Valori restituiti

Ereditato da EventEmitter.listenerCount

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<K>(eventName: string | symbol): Function[]

Parametri

Valori restituiti

Ereditato da EventEmitter.listener

Alias per emitter.removeListener().

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

Parametri

Valori restituiti

Ereditato da EventEmitter.off

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Ritorna e AsyncIterator che itera eventName gli eventi. Lancerà se emette EventEmitter'error'. Rimuove tutti gli ascoltatori quando esce dal loop. Il value ritorno di ogni iterazione è un array composto dagli argomenti dell'evento emesso.

An può essere usato per annullare l'attesa AbortSignal degli eventi:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

Usa l'opzione close per specificare un array di nomi di eventi che concluderanno l'iterazione:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parametri

Valori restituiti

E AsyncIterator che itera eventName gli eventi emessi dal emitter

Ereditato da EventEmitter.on

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parametri

Valori restituiti

Ereditato da EventEmitter.on

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<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parametri

Valori restituiti

Ereditato da EventEmitter.on

Crea un Promise che viene soddisfatto quando emette EventEmitter l'evento dato o che viene rifiutato se emette 'error'EventEmitter mentre è in attesa. Si Promise risolverà con una serie di tutti gli argomenti emessi all'evento dato.

Questo metodo è intenzionalmente generico e funziona con l'interfaccia della piattaforma web EventTarget , che non ha semantica degli eventi speciali'error' e non ascolta l'evento 'error' .

import { once, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

La gestione speciale dell'evento 'error' viene utilizzata solo quando events.once() viene usata per aspettare un altro evento. Se events.once() viene usato per attendere l'evento 'error' stesso, allora viene trattato come qualsiasi altro tipo di evento senza una gestione speciale:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

An può essere usato per annullare l'attesa AbortSignal dell'evento:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

static function once(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>

Parametri

Valori restituiti

ereditato da EventEmitter.once

static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>

Parametri

Valori restituiti

ereditato da EventEmitter.once

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<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parametri

Valori restituiti

ereditato da EventEmitter.once

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<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parametri

Valori restituiti

Ereditato da EventEmitter.prependListener

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<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parametri

Valori restituiti

Ereditato da EventEmitter.prependOnceListener

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<K>(eventName: string | symbol): Function[]

Parametri

Valori restituiti

ereditato da EventEmitter.rawListeners

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

Parametri

Valori restituiti

Ereditato da EventEmitter.removeAllListeners

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 o chiamate dopo l'emissione e l' prima che l'ultima esecuzione del listener non li rimuoverà dal 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é i listener vengono gestiti usando una matrice interna, la chiamata di questo modificherà gli indici di posizione di qualsiasi listener registrato dopo la rimozione del listener. 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<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Parametri

Valori restituiti

Ereditato da EventEmitter.removeListener

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

Parametri

Valori restituiti

Ereditato da EventEmitter.setMaxListeners

import { setMaxListeners, EventEmitter } from 'node:events';

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);

static function setMaxListeners(n?: number, eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[])

Parametri

Ereditato da EventEmitter.setMaxListeners

function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)

Parametri

Ereditato da EventEmitter.__@captureRejectionSymbol@118