Receiver interface

function on(type: "errorReceived", func: (err: Error) => void): Receiver

Parameter

Gibt zurück

function on(type: "message", func: (msg: Message) => void): Receiver

Parameter

Gibt zurück

function on(type: string, func: Function): Receiver

Parameter

Gibt zurück

Alias für emitter.on(eventName, listener).

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

Parameter

Gibt zurück

Geerbt von EventEmitter.addListener

Ruft synchron alle Listener auf, die für das Ereignis namens eventNameregistriert sind, in der Reihenfolge, in der sie registriert wurden, und übergibt die angegebenen Argumente an jeden.

Gibt zurück true , wenn das Ereignis über Listener verfügt, false andernfalls.

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

Parameter

Gibt zurück

Geerbt von EventEmitter.emit

Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter über registrierte Listener verfügt. Die Werte im Array sind Zeichenfolgen oder 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)[]

Gibt zurück

Geerbt von EventEmitter.eventNames

Gibt den aktuellen maximalen Listenerwert für den zurück, der EventEmitter entweder von emitter.setMaxListeners(n) oder standardmäßig auf <xref:defaultMaxListeners>festgelegt ist.

function getMaxListeners(): number

Gibt zurück

Geerbt von EventEmitter.getMaxListeners

Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen eventNamelauschen. Wenn listener angegeben, wird zurückgegeben, wie oft der Listener in der Liste der Listener des Ereignisses gefunden wird.

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

Parameter

Gibt zurück

Geerbt von EventEmitter.listenerCount

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen zurück 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[]

Parameter

Gibt zurück

Geerbt von EventEmitter.listeners

Alias für emitter.removeListener().

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

Parameter

Gibt zurück

Geerbt von EventEmitter.off

Fügt eine einmaligelistener Funktion für das Ereignis mit dem Namen hinzu eventName. Wenn das nächste Mal eventName ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen.

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

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.

Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die emitter.prependOnceListener() -Methode kann als Alternative verwendet werden, um den Ereignislistener am Anfang des Listenerarrays hinzuzufügen.

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

Parameter

Gibt zurück

Geerbt von EventEmitter.once

Fügt die listener Funktion am Anfang des Listenerarrays für das Ereignis mit dem Namen hinzu eventName. Es werden keine Überprüfungen durchgeführt, um festzustellen, ob der listener bereits hinzugefügt wurde. Mehrere Aufrufe, die die gleiche Kombination von eventName und listener übergeben, führen dazu, dass der listener mehrmals hinzugefügt und aufgerufen wird.

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

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.

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

Parameter

Gibt zurück

Geerbt von EventEmitter.prependListener

Fügt eine einmaligelistener Funktion für das Ereignis mit dem Namen eventName am Anfang des Listenerarrays hinzu. Wenn das nächste Mal eventName ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen.

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

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.

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

Parameter

Gibt zurück

Geerbt von EventEmitter.prependOnceListener

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen zurück eventName, einschließlich aller Wrapper (z. B. von .once()erstellten ).

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

Parameter

Gibt zurück

Geerbt von EventEmitter.rawListeners

Entfernt alle Listener oder die des angegebenen eventName.

Es empfiehlt sich, Listener zu entfernen, die an anderer Stelle im Code hinzugefügt wurden, insbesondere wenn die EventEmitter instance von einer anderen Komponente oder einem anderen Modul (z. B. Sockets oder Dateistreams) erstellt wurde.

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.

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

Parameter

Gibt zurück

Geerbt von EventEmitter.removeAllListeners

Entfernt das angegebene listener aus dem Listenerarray für das Ereignis mit dem Namen eventName.

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

removeListener()entfernt höchstens einen instance eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für den angegebenen eventNamehinzugefügt wurde, removeListener() muss mehrmals aufgerufen werden, um jeden instance zu entfernen.

Sobald ein Ereignis ausgegeben wurde, werden alle Listener, die zum Zeitpunkt der Ausgabe an das Ereignis angefügt sind, in der Reihenfolge aufgerufen. Dies bedeutet, dass Aufrufe removeListener()oderremoveAllListeners() nach dem Ausgeben und vor Abschluss der ausführung des letzten Listeners sie nicht aus deremit() laufenden Ausführung entfernen. Nachfolgende Ereignisse verhalten sich wie erwartet.

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

Da Listener mithilfe eines internen Arrays verwaltet werden, werden die Positionsindizes aller Listener geändert, die nach dem Entfernen des Listeners registriert wurden. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden, bedeutet jedoch, dass alle Kopien des Listenerarrays, wie sie von der emitter.listeners() -Methode zurückgegeben werden, neu erstellt werden müssen.

Wenn eine einzelne Funktion mehrmals als Handler für ein einzelnes Ereignis hinzugefügt wurde (wie im folgenden Beispiel), removeListener() wird die zuletzt hinzugefügte instance entfernt. Im Beispiel wird der once('ping') Listener entfernt:

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

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.

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

Parameter

Gibt zurück

Geerbt von EventEmitter.removeListener

Standardmäßig EventEmittergibt s eine Warnung aus, wenn für ein bestimmtes Ereignis mehr als 10 Listener hinzugefügt werden. Dies ist ein nützlicher Standard, mit dem Speicherverluste gefunden werden können. Mit emitter.setMaxListeners() der -Methode kann der Grenzwert für diese spezifische EventEmitter instance geändert werden. Der Wert kann auf Infinity (oder 0) festgelegt werden, um eine unbegrenzte Anzahl von Listenern anzugeben.

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.

function setMaxListeners(n: number): Receiver

Parameter

Gibt zurück

Geerbt von EventEmitter.setMaxListeners

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

Parameter

Geerbt von EventEmitter.__@captureRejectionSymbol@91