Twin class

static desiredPath: string

Valore della proprietà

static errorEvent: string

Valore della proprietà

Dizionari delle proprietà desiderati e segnalati (rispettivamente in properties.desired e properties.reported).

properties: TwinProperties

Valore della proprietà

userRegisteredDesiredPropertiesListener: boolean

Valore della proprietà

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 get(): Promise<Twin>

Valori restituiti

Ottiene l'intero gemello dal servizio.

function get(callback?: Callback<Twin>)

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

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

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

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

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

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

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

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

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

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@141