Twin class

static desiredPath: string

Wartość właściwości

static errorEvent: string

Wartość właściwości

Żądane i zgłoszone słowniki właściwości (odpowiednio w properties.desired i properties.reported).

properties: TwinProperties

Wartość właściwości

userRegisteredDesiredPropertiesListener: boolean

Wartość właściwości

Wartość: boolean

Zmień domyślną captureRejections opcję na wszystkich nowych EventEmitter obiektach.

static captureRejections: boolean

Wartość właściwości

Dziedziczone z EventEmiter.captureObjections

Wartość: Symbol.for('nodejs.rejection')

Zobacz, jak napisać niestandardową rejection handlerwersję .

static captureRejectionSymbol: typeof captureRejectionSymbol

Wartość właściwości

Dziedziczone z EventEmitter.captureRejeSymbol

Domyślnie maksymalna liczba 10 słuchaczy może być zarejestrowana na dowolne wydarzenie. Limit ten można zmieniać dla poszczególnych EventEmitter instancji za pomocą tej metody emitter.setMaxListeners(n) . Aby zmienić domyślne ustawienia dla wszystkichEventEmitter instancji, events.defaultMaxListeners można użyć tej właściwości. Jeśli ta wartość nie jest dodatnią, rzuca się a RangeError .

Zachowaj ostrożność przy ustawianiu, events.defaultMaxListeners ponieważ zmiana dotyczy wszystkichEventEmitter instancji, w tym tych utworzonych przed jej wprowadzeniem. Jednak wywoływanie emitter.setMaxListeners(n) nadal ma pierwszeństwo nad events.defaultMaxListeners.

To nie jest twardy limit. Instancja EventEmitter pozwala na dodanie większej liczby słuchaczy, ale wygeneruje ostrzeżenie o śladzie do stderr, sygnalizujące wykrycie "możliwego wycieku pamięci EventEmitter". Dla dowolnego pojedynczego EventEmitter, emitter.getMaxListeners() metody i emitter.setMaxListeners() mogą być użyte do tymczasowego uniknięcia tego ostrzeżenia:

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

Flaga --trace-warnings wiersza poleceń może być użyta do wyświetlania śladu stosu dla takich ostrzeżeń.

Emitowane ostrzeżenie można sprawdzić za pomocą process.on('warning') i będzie zawierać emitterdodatkowe , type, oraz count właściwości, odnoszące się odpowiednio do instancji emitora zdarzenia, nazwy zdarzenia oraz liczby podłączonych słuchaczy. Jego name własność jest ustawiona na .'MaxListenersExceededWarning'

static defaultMaxListeners: number

Wartość właściwości

Dziedziczone z EventEmitter.defaultMaxListeners

Ten symbol powinien być używany do instalacji nasłuchiwacza, który służy wyłącznie do monitorowania 'error' zdarzeń. Słuchacze zainstalowani za pomocą tego symbolu są wywoływani przed regularnymi 'error' słuchaczami.

Zainstalowanie słuchacza za pomocą tego symbolu nie zmienia zachowania po 'error' wygenerowaniu zdarzenia. Dlatego proces nadal się zawiesił, jeśli nie 'error' zainstalowano regularnego nasłuchiwacza.

static errorMonitor: typeof errorMonitor

Wartość właściwości

Dziedziczone z EventEmitter.errorMonitor

function get(): Promise<Twin>

Zwraca

Pobiera całą reprezentację bliźniacze z usługi.

function get(callback?: Callback<Twin>)

Parametry

Słucha raz wydarzenia abort na poleconym signalkoncie.

Nasłuchiwanie abort zdarzenia na sygnałach przerwania jest niebezpieczne i może prowadzić do wycieków zasobów, ponieważ inna osoba trzecia z sygnałem może zadzwonić e.stopImmediatePropagation(). Niestety Node.js tego nie zmienić, bo naruszałoby to standard internetowy. Dodatkowo oryginalne API ułatwia zapomnienie usunięcia słuchaczy.

To API pozwala bezpiecznie używać AbortSignals w Node.js API, rozwiązując te dwa problemy poprzez nasłuchiwanie zdarzenia w taki sposób, by stopImmediatePropagation nie uniemożliwiać uruchomienia nasłuchowcy.

Zwraca jednorazowy, aby łatwiej się z niego wypisać.

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

Parametry

Zwraca

Jednorazowe, które odbiera abort słuchacza.

Dziedziczone z EventEmitter.addAbortListener

Alias dla emitter.on(eventName, listener).

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

Parametry

Zwraca

dziedziczone z EventEmitter.addListener

Synchronicznie wywołuje każdy odbiornik zarejestrowany dla zdarzenia o nazwie eventName, w kolejności, w której zostały zarejestrowane, przekazując podane argumenty do każdego.

Zwraca true, jeśli zdarzenie miało odbiorniki, false w przeciwnym razie.

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

Parametry

Zwraca

dziedziczone z EventEmitter.emit

Zwraca tablicę z listą zdarzeń, dla których emiter zarejestrował odbiorniki. Wartości w tablicy to ciągi lub 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)[]

Zwraca

dziedziczone z EventEmitter.eventNames

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

Dla EventEmitters zachowuje się to dokładnie tak samo jak wywołanie .listeners emitera.

Dla EventTargets to jedyny sposób, by zdobyć odbiorców wydarzenia dla docelowego wydarzenia. Jest to przydatne do debugowania i diagnostyki.

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

Parametry

Zwraca

Odziedziczone z EventEmitter.getEventListeners

Zwraca bieżącą wartość maksymalnego odbiornika dla EventEmitter, która jest ustawiona przez emitter.setMaxListeners(n) lub domyślnie ma wartość <xref:EventEmitter.defaultMaxListeners>.

function getMaxListeners(): number

Zwraca

dziedziczone z EventEmitter.getMaxListeners

Zwraca aktualnie ustaloną maksymalną liczbę słuchaczy.

Dla EventEmitters zachowuje się to dokładnie tak samo jak wywołanie .getMaxListeners emitera.

Dla EventTargets to jedyny sposób, aby uzyskać maksymalną liczbę słuchaczy zdarzeń dla docelowego wydarzenia. Jeśli liczba obsługiwaczy zdarzeń na jednym EventTarget przekroczy maksymalny zestaw, EventTarget wydrukuje ostrzeżenie.

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

Parametry

Zwraca

dziedziczone z EventEmitter.getMaxListeners

Metoda klasowa zwracająca liczbę słuchaczy dla danego eventName rejestru na danym 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

Parametry

Zwraca

dziedziczone z EventEmitter.listenerCount

Zwraca liczbę odbiorników nasłuchujących zdarzenia o nazwie eventName. W przypadku podania listener zostanie zwrócona liczba znalezionych odbiorników na liście odbiorników zdarzenia.

function listenerCount<K>(eventName: string | symbol, listener?: Function): number

Parametry

Zwraca

dziedziczone z EventEmitter.listenerCount

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie 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[]

Parametry

Zwraca

dziedziczone z EventEmitter.listeners

Alias dla emitter.removeListener().

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

Parametry

Zwraca

dziedziczone z 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

Zwraca i AsyncIterator iteruje eventName zdarzenia. Będzie rzucać, jeśli wyemituje EventEmitter'error'. Usuwa wszystkich słuchaczy po wyjściu z pętli. Zwrócony value przez każdą iterację to tablica złożona z argumentów wyemitowanych zdarzeń.

An może być użyte do anulowania oczekiwania AbortSignal na wydarzenia:

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

Użyj close opcji określenia tablicy nazw zdarzeń, która zakończy iterację:

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>

Parametry

Zwraca

A AsyncIterator , która iteruje eventName zdarzenia emitowane przez emitter

dziedziczone z EventEmitter.on

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

Parametry

Zwraca

dziedziczone z EventEmitter.on

Dodaje funkcję listener na końcu tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

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

Parametry

Zwraca

dziedziczone z EventEmitter.on

Tworzy , Promise które jest spełnione, gdy emituje EventEmitter dane zdarzenie, lub które jest odrzucane, jeśli emituje 'error' podczas EventEmitter oczekiwania. Rozstrzygnie się Promise za pomocą tablicy wszystkich argumentów wydanych dla danego zdarzenia.

Ta metoda jest celowo ogólna i działa z interfejsem platformy internetowej EventTarget , która nie posiada semantyki specjalnych'error' zdarzeń i nie słucha 'error' zdarzenia.

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

Specjalne zarządzanie wydarzeniem 'error' jest stosowane tylko wtedy, gdy events.once() jest używane do oczekiwania na inne wydarzenie. Jeśli events.once() jest używany do oczekiwania naerror' samo 'zdarzenie', to traktuje się go jak każde inne zdarzenie bez specjalnego traktowania:

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 może być użyte do odwołania oczekiwania AbortSignal na wydarzenie:

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

Parametry

Zwraca

dziedziczone z EventEmitter.once

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

Parametry

Zwraca

dziedziczone z EventEmitter.once

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName. Przy następnym wyzwoleniu eventName ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependOnceListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

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

Parametry

Zwraca

dziedziczone z EventEmitter.once

Dodaje funkcję listener do rozpoczynającej się tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

Zwraca

dziedziczone z EventEmitter.prependListener

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName do rozpoczynającej się tablicy odbiorników. Następnym razem, gdy eventName zostanie wyzwolony, ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

Zwraca

dziedziczone z EventEmitter.prependOnceListener

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName, w tym wszelkie otoki (takie jak te utworzone przez .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[]

Parametry

Zwraca

dziedziczone z EventEmitter.rawListeners

Usuwa wszystkie odbiorniki lub te z określonych eventName.

Źle jest usunąć odbiorniki dodane gdzie indziej w kodzie, szczególnie w przypadku utworzenia wystąpienia EventEmitter przez inny składnik lub moduł (np. gniazda lub strumienie plików).

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

Zwraca

dziedziczone z EventEmitter.removeAllListeners

Usuwa określone listener z tablicy odbiorników dla zdarzenia o nazwie eventName.

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

removeListener() usunie co najwyżej jedno wystąpienie odbiornika z tablicy odbiornika. Jeśli jakikolwiek pojedynczy odbiornik został dodany wiele razy do tablicy odbiornika dla określonego eventName, removeListener() należy wywołać wiele razy, aby usunąć każde wystąpienie.

Po emitowaniu zdarzenia wszystkie odbiorniki dołączone do niego w momencie emitowania są wywoływane w kolejności. Oznacza to, że wszystkie wywołania removeListener() lub removeAllListeners()po emitowaniu i przed ostatnie wykonanie odbiornika nie spowoduje usunięcia ich zemit() w toku. Kolejne zdarzenia zachowują się zgodnie z oczekiwaniami.

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

Ponieważ odbiorniki są zarządzane przy użyciu tablicy wewnętrznej, wywołanie spowoduje zmianę indeksów pozycji dowolnego odbiornika zarejestrowanego po usunięcia odbiornika. Nie będzie to miało wpływu na kolejność wywoływanych odbiorników, ale oznacza to, że wszystkie kopie tablicy odbiorników zwrócone przez metodę emitter.listeners() będą musiały zostać ponownie odtworzone.

Gdy pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie), removeListener() usunie ostatnio dodane wystąpienie. W przykładzie odbiornik once('ping') zostanie usunięty:

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

Zwraca

dziedziczone z EventEmitter.removeListener

Domyślnie EventEmitters wyświetli ostrzeżenie, jeśli dla określonego zdarzenia zostanie dodane więcej niż 10 odbiorniki. Jest to przydatna wartość domyślna, która ułatwia znajdowanie przecieków pamięci. Metoda emitter.setMaxListeners() umożliwia zmodyfikowanie limitu dla tego konkretnego wystąpienia EventEmitter. Wartość można ustawić na Infinity (lub 0), aby wskazać nieograniczoną liczbę odbiorników.

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

function setMaxListeners(n: number): Twin

Parametry

Zwraca

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

Parametry

dziedziczone z EventEmitter.setMaxListeners

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

Parametry

Dziedziczone od EventEmitter.__@captureRejectionSymbol@141