Twin class
Ein Device Twin-Dokument beschreibt den Zustand eines Geräts, das von einem Azure IoT-Hub gespeichert wird und auch verfügbar ist, wenn das Gerät offline ist. Es wird um 3 Abschnitte gebaut:
- Tags: Schlüssel-Wert-Paare, auf die nur über die Dienstseite zugegriffen werden kann
- Gewünschte Eigenschaften: von einem Dienst aktualisiert und vom Gerät empfangen
- Gemeldete Eigenschaften: vom Gerät aktualisiert und vom Dienst empfangen.
Beachten Sie, dass die Logik zum Synchronisieren dieser beiden Auflistungen, falls erforderlich, dem Benutzer des SDK überlassen wird, obwohl es eine Möglichkeit ist, gewünschte und gemeldete Eigenschaften nicht übereinstimmen zu müssen.
Weitere Informationen finden Sie unter Understanding Device Twins.
- Extends
-
EventEmitter
desired |
|
error |
|
properties | Die gewünschten und gemeldeten Eigenschaftenwörterbücher (bzw. in |
user |
capture |
Wert: booleschen Ändern Sie die Standardoption |
capture |
Wert: Erfahren Sie, wie Sie eine benutzerdefinierte |
default |
Standardmäßig können maximal Achten Sie beim Festlegen der Dies ist kein hartes Limit. Die
Das Die ausgegebene Warnung kann mit |
error |
Dieses Symbol wird verwendet, um einen Listener nur für die Überwachung Das Installieren eines Listeners mit diesem Symbol ändert das Verhalten nicht, sobald ein |
get() | |
get(Callback<Twin>) | Ruft den gesamten Zwilling vom Dienst ab. |
add |
Lauscht einmal auf das Das Abbruchsignal des Diese API ermöglicht die sichere Verwendung von Gibt ein Einweg zurück, damit es einfacher abbestellt werden kann.
|
add |
Alias für |
emit<K>(string | symbol, Any |
Ruft die einzelnen Listener synchron auf, die für das Ereignis mit dem Namen Gibt
|
event |
Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter Listener registriert hat. Die Werte im Array sind Zeichenfolgen oder
|
get |
Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen Bei Für
|
get |
Gibt den aktuellen Maximallistenerwert für die |
get |
Gibt die derzeit festgelegte maximale Anzahl von Listenern zurück. Bei Für
|
listener |
Eine Klassenmethode, die die Anzahl der Listener für die angegebene
|
listener |
Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen |
listeners<K>(string | symbol) | Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen
|
off<K>(string | symbol, (args: any[]) => void) | Alias für |
on(Event |
Gibt einen Ein
Verwenden Sie die Option
|
on(Event |
|
on<K>(string | symbol, (args: any[]) => void) | Fügt die
Gibt einen Verweis auf die Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die
|
once(Event |
Erstellt eine Diese Methode ist absichtlich generisch und arbeitet mit der Webplattform EventTarget Schnittstelle, die keine spezielle
Die spezielle Behandlung des
Ein
|
once(Event |
|
once<K>(string | symbol, (args: any[]) => void) | Fügt eine einmalige
Gibt einen Verweis auf die Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die
|
prepend |
Fügt die
Gibt einen Verweis auf die |
prepend |
Fügt dem beginnenden des Listenersarrays eine
Gibt einen Verweis auf die |
raw |
Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen
|
remove |
Entfernt alle Listener oder die der angegebenen Es empfiehlt sich, Listener zu entfernen, die an anderer Stelle im Code hinzugefügt wurden, insbesondere, wenn die Gibt einen Verweis auf die |
remove |
Entfernt die angegebene
Sobald ein Ereignis ausgegeben wird, werden alle listener, die zum Zeitpunkt der Ausstrahlung an sie angefügt sind, in der Reihenfolge aufgerufen. Dies bedeutet, dass alle
Da Listener mithilfe eines internen Arrays verwaltet werden, ändert das Aufrufen die Positionsindizes aller listener, die registriert sind, nachdem der Listener entfernt wurde. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden. Dies bedeutet jedoch, dass alle Kopien des Listenerarrays, wie sie von der Wenn eine einzelne Funktion mehrmals als Handler für ein einzelnes Ereignis (wie im folgenden Beispiel) hinzugefügt wurde, entfernt
Gibt einen Verweis auf die |
set |
Standardmäßig druckt Gibt einen Verweis auf die |
set |
|
[capture |
static desiredPath: string
Eigenschaftswert
string
static errorEvent: string
Eigenschaftswert
string
Die gewünschten und gemeldeten Eigenschaftenwörterbücher (bzw. in properties.desired
und properties.reported
).
properties: TwinProperties
Eigenschaftswert
userRegisteredDesiredPropertiesListener: boolean
Eigenschaftswert
boolean
Wert: booleschen
Ändern Sie die Standardoption captureRejections
für alle neuen EventEmitter
-Objekte.
static captureRejections: boolean
Eigenschaftswert
boolean
geerbt von EventEmitter.captureRejections
Wert: Symbol.for('nodejs.rejection')
Erfahren Sie, wie Sie eine benutzerdefinierte rejection handler
schreiben.
static captureRejectionSymbol: typeof captureRejectionSymbol
Eigenschaftswert
typeof captureRejectionSymbol
geerbt von EventEmitter.captureRejectionSymbol
Standardmäßig können maximal 10
Listener für jedes einzelne Ereignis registriert werden. Dieser Grenzwert kann für einzelne EventEmitter
Instanzen mithilfe der emitter.setMaxListeners(n)
-Methode geändert werden. Um den Standardwert für alleEventEmitter
Instanzen zu ändern, kann die eigenschaft events.defaultMaxListeners
verwendet werden. Wenn dieser Wert keine positive Zahl ist, wird ein RangeError
ausgelöst.
Achten Sie beim Festlegen der events.defaultMaxListeners
darauf, dass sich die Änderung auf alleEventEmitter
Instanzen auswirkt, einschließlich derjenigen, die vor der Änderung erstellt wurden. Das Aufrufen von emitter.setMaxListeners(n)
hat jedoch weiterhin Vorrang vor events.defaultMaxListeners
.
Dies ist kein hartes Limit. Die EventEmitter
Instanz ermöglicht das Hinzufügen weiterer Listener, gibt jedoch eine Ablaufverfolgungswarnung an stderr aus, die angibt, dass ein "möglicher EventEmitter-Speicherverlust" erkannt wurde. Bei jedem einzelnen EventEmitter
können die Methoden emitter.getMaxListeners()
und emitter.setMaxListeners()
verwendet werden, um diese Warnung vorübergehend zu vermeiden:
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));
});
Das --trace-warnings
Befehlszeilenflagge kann verwendet werden, um die Stapelablaufverfolgung für solche Warnungen anzuzeigen.
Die ausgegebene Warnung kann mit process.on('warning')
geprüft werden und verfügt über die zusätzlichen emitter
, type
und count
Eigenschaften, die auf die Ereignisausgeberinstanz verweisen, den Namen des Ereignisses und die Anzahl der angefügten Listener.
Die name
-Eigenschaft ist auf 'MaxListenersExceededWarning'
festgelegt.
static defaultMaxListeners: number
Eigenschaftswert
number
von EventEmitter.defaultMaxListeners geerbt
Dieses Symbol wird verwendet, um einen Listener nur für die Überwachung 'error'
Ereignisse zu installieren. Listener, die mit diesem Symbol installiert sind, werden aufgerufen, bevor die regulären 'error'
Listener aufgerufen werden.
Das Installieren eines Listeners mit diesem Symbol ändert das Verhalten nicht, sobald ein 'error'
Ereignis ausgegeben wird. Daher stürzt der Vorgang weiterhin ab, wenn kein regulärer 'error'
Listener installiert ist.
static errorMonitor: typeof errorMonitor
Eigenschaftswert
typeof errorMonitor
Von EventEmitter.errorMonitor geerbt
Ruft den gesamten Zwilling vom Dienst ab.
function get(callback?: Callback<Twin>)
Parameter
- callback
-
Callback<Twin>
optionale Funktion, die entweder mit dem Zwilling oder einem Fehler zurück aufgerufen werden soll, wenn der Transport den Zwilling nicht abruft.
Lauscht einmal auf das abort
Ereignis auf der bereitgestellten signal
.
Das Abbruchsignal des abort
-Ereignisses ist unsicher und kann zu Ressourcenlecks führen, da ein anderer Drittanbieter mit dem Signal e.stopImmediatePropagation()
aufrufen kann. Leider kann Node.js dies nicht ändern, da sie gegen den Webstandard verstoßen würde. Darüber hinaus erleichtert die ursprüngliche API das Entfernen von Listenern.
Diese API ermöglicht die sichere Verwendung von AbortSignal
s in Node.js-APIs, indem diese beiden Probleme gelöst werden, indem das Ereignis überwacht wird, sodass stopImmediatePropagation
die Ausführung des Listeners nicht verhindert.
Gibt ein Einweg zurück, damit es einfacher abbestellt werden kann.
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
Parameter
- signal
-
AbortSignal
- resource
-
(event: Event) => void
Gibt zurück
Disposable
Einweg, der den abort
Listener entfernt.
geerbt von EventEmitter.addAbortListener
Alias für emitter.on(eventName, listener)
.
function addListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Twin
Parameter
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Gibt zurück
Geerbt von EventEmitter.addListener
Ruft die einzelnen Listener synchron auf, die für das Ereignis mit dem Namen eventName
registriert wurden, in der Reihenfolge, in der sie registriert wurden, und übergibt die angegebenen Argumente an jedes Ereignis.
Gibt true
zurück, wenn das Ereignis Listener hatte, 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
- eventName
-
string | symbol
- args
-
AnyRest
Gibt zurück
boolean
von EventEmitter.emit geerbt
Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter Listener registriert hat. Die Werte im Array sind Zeichenfolgen oder Symbol
s.
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
(string | symbol)[]
Geerbt von EventEmitter.eventNames
Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventName
zurück.
Bei EventEmitter
verhält sich dies genau so wie das Aufrufen von .listeners
für den Emitter.
Für EventTarget
ist dies die einzige Möglichkeit, die Ereignislistener für das Ereignisziel abzurufen. Dies ist nützlich für Debugging- und Diagnosezwecke.
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[]
Parameter
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
- name
-
string | symbol
Gibt zurück
Function[]
Geerbt von EventEmitter.getEventListeners
Gibt den aktuellen Maximallistenerwert für die EventEmitter
zurück, die entweder durch emitter.setMaxListeners(n)
oder standardmäßig auf defaultMaxListenersfestgelegt ist.
function getMaxListeners(): number
Gibt zurück
number
Geerbt von EventEmitter.getMaxListeners
Gibt die derzeit festgelegte maximale Anzahl von Listenern zurück.
Bei EventEmitter
verhält sich dies genau so wie das Aufrufen von .getMaxListeners
für den Emitter.
Für EventTarget
ist dies die einzige Möglichkeit, die maximalen Ereignislistener für das Ereignisziel abzurufen. Wenn die Anzahl der Ereignishandler für ein einzelnes EventTarget den maximalen Satz überschreitet, gibt eventTarget eine Warnung aus.
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
Parameter
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
Gibt zurück
number
Geerbt von EventEmitter.getMaxListeners
Warnung
Diese API ist nun veraltet.
Since v3.2.0 - Use listenerCount
instead.
Eine Klassenmethode, die die Anzahl der Listener für die angegebene eventName
zurückgibt, die für die angegebene emitter
registriert sind.
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
Parameter
- emitter
-
EventEmitter<DefaultEventMap>
Der zu abfragende Emitter
- eventName
-
string | symbol
Der Ereignisname
Gibt zurück
number
geerbt von EventEmitter.listenerCount
Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen eventName
lauschen.
Wenn listener
angegeben wird, 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
- eventName
-
string | symbol
Der Name des Ereignisses, auf das gewartet wird
- listener
-
Function
Die Ereignishandlerfunktion
Gibt zurück
number
geerbt von EventEmitter.listenerCount
Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventName
zurück.
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
- eventName
-
string | symbol
Gibt zurück
Function[]
von EventEmitter.listeners geerbt
Alias für emitter.removeListener()
.
function off<K>(eventName: string | symbol, listener: (args: any[]) => void): Twin
Parameter
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Gibt zurück
von EventEmitter.off geerbt
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
Gibt einen AsyncIterator
zurück, der eventName
Ereignisse durchläuft. Es wird ausgelöst, wenn die EventEmitter
'error'
ausgibt. Beim Beenden der Schleife werden alle Listener entfernt. Die von jeder Iteration zurückgegebene value
ist ein Array, das aus den ausgegebenen Ereignisargumenten besteht.
Ein AbortSignal
kann verwendet werden, um das Warten auf Ereignisse abzubrechen:
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());
Verwenden Sie die Option close
, um ein Array von Ereignisnamen anzugeben, das die Iteration beendet:
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>
Parameter
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string | symbol
- options
-
StaticEventEmitterIteratorOptions
Gibt zurück
AsyncIterator<any[], any, any>
Eine AsyncIterator
, die von der eventName
ausgegebene emitter
Ereignisse durchläuft
von EventEmitter.on geerbt
static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>
Parameter
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterIteratorOptions
Gibt zurück
AsyncIterator<any[], any, any>
von EventEmitter.on geerbt
Fügt die listener
-Funktion am Ende des Listenerarrays für das Ereignis mit dem Namen eventName
hinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die listener
bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus eventName
übergeben, und listener
führen dazu, dass die listener
mehrmals hinzugefügt und aufgerufen wird.
server.on('connection', (stream) => {
console.log('someone connected!');
});
Gibt einen Verweis auf die EventEmitter
zurück, sodass Aufrufe verkettet werden können.
Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die emitter.prependListener()
-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden.
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
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
von EventEmitter.on geerbt
Erstellt eine Promise
, die erfüllt wird, wenn die EventEmitter
das angegebene Ereignis ausgibt oder abgelehnt wird, wenn die EventEmitter
beim Warten 'error'
ausgibt.
Die Promise
wird mit einem Array aller Argumente aufgelöst, die an das angegebene Ereignis ausgegeben werden.
Diese Methode ist absichtlich generisch und arbeitet mit der Webplattform EventTarget Schnittstelle, die keine spezielle'error'
Ereignissemantik aufweist und nicht auf das 'error'
Ereignis lauscht.
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);
}
Die spezielle Behandlung des 'error'
-Ereignisses wird nur verwendet, wenn events.once()
verwendet wird, um auf ein anderes Ereignis zu warten. Wenn events.once()
verwendet wird, um auf das ereignis "error'
selbst zu warten, wird es als jede andere Art von Ereignis ohne spezielle Behandlung behandelt:
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
Ein AbortSignal
kann verwendet werden, um das Warten auf das Ereignis abzubrechen:
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[]>
Parameter
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string | symbol
- options
-
StaticEventEmitterOptions
Gibt zurück
Promise<any[]>
von EventEmitter geerbt.once
static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>
Parameter
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterOptions
Gibt zurück
Promise<any[]>
von EventEmitter geerbt.once
Fügt eine einmaligelistener
-Funktion für das Ereignis mit dem Namen eventName
hinzu. Wenn eventName
das nächste Mal 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 die EventEmitter
zurück, sodass 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 zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden.
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
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
von EventEmitter geerbt.once
Fügt die listener
-Funktion dem beginnenden des Listenersarrays für das Ereignis mit dem Namen eventName
hinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die listener
bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus eventName
übergeben, und listener
führen dazu, dass die listener
mehrmals hinzugefügt und aufgerufen wird.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
Gibt einen Verweis auf die EventEmitter
zurück, sodass Aufrufe verkettet werden können.
function prependListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Twin
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
Geerbt von EventEmitter.prependListener
Fügt dem beginnenden des Listenersarrays eine listener
eventName
Funktion für das Ereignis hinzu, das genannt wird. Wenn eventName
das nächste Mal 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 die EventEmitter
zurück, sodass Aufrufe verkettet werden können.
function prependOnceListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Twin
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
geerbt von EventEmitter.prependOnceListener
Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventName
zurück, einschließlich aller Wrapper (z. B. von .once()
erstellt).
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
- eventName
-
string | symbol
Gibt zurück
Function[]
von EventEmitter.rawListeners geerbt
Entfernt alle Listener oder die der angegebenen eventName
.
Es empfiehlt sich, Listener zu entfernen, die an anderer Stelle im Code hinzugefügt wurden, insbesondere, wenn die EventEmitter
Instanz von einer anderen Komponente oder einem anderen Modul (z. B. Sockets oder Dateistreams) erstellt wurde.
Gibt einen Verweis auf die EventEmitter
zurück, sodass Aufrufe verkettet werden können.
function removeAllListeners(eventName?: string | symbol): Twin
Parameter
- eventName
-
string | symbol
Gibt zurück
geerbt von EventEmitter.removeAllListeners
Entfernt die 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 eine Instanz eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für die angegebene eventName
hinzugefügt wurde, muss removeListener()
mehrmals aufgerufen werden, um jede Instanz zu entfernen.
Sobald ein Ereignis ausgegeben wird, werden alle listener, die zum Zeitpunkt der Ausstrahlung an sie angefügt sind, in der Reihenfolge aufgerufen. Dies bedeutet, dass alle removeListener()
oder removeAllListeners()
Aufrufe nach Senden und , bevor die letzte Listenerausführung beendet wird, diese nicht ausemit()
entfernt. 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, ändert das Aufrufen die Positionsindizes aller listener, die registriert sind, nachdem der Listener entfernt wurde. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden. Dies 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 (wie im folgenden Beispiel) hinzugefügt wurde, entfernt removeListener()
die zuletzt hinzugefügte Instanz. 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 die EventEmitter
zurück, sodass Aufrufe verkettet werden können.
function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Twin
Parameter
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Gibt zurück
Geerbt von EventEmitter.removeListener
Standardmäßig druckt EventEmitter
s eine Warnung, wenn für ein bestimmtes Ereignis mehr als 10
Listener hinzugefügt werden. Dies ist ein nützlicher Standardwert, der hilft, Speicherverluste zu finden. Mit der emitter.setMaxListeners()
-Methode kann der Grenzwert für diese spezifische EventEmitter
Instanz geändert werden. Der Wert kann auf Infinity
(oder 0
) festgelegt werden, um eine unbegrenzte Anzahl von Listenern anzugeben.
Gibt einen Verweis auf die EventEmitter
zurück, sodass Aufrufe verkettet werden können.
function setMaxListeners(n: number): Twin
Parameter
- n
-
number
Gibt zurück
Geerbt von 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)[])
Parameter
- n
-
number
Eine nicht negative Zahl. Die maximale Anzahl von Listenern pro EventTarget
Ereignis.
- eventTargets
-
(EventEmitter<DefaultEventMap> | EventTarget)[]
Null oder mehr {EventTarget}- oder {EventEmitter}-Instanzen. Wenn keine angegeben wird, wird n
als Standard-Max für alle neu erstellten {EventTarget}- und {EventEmitter}-Objekte festgelegt.
Geerbt von EventEmitter.setMaxListeners
function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)
Parameter
- error
-
Error
- event
-
string | symbol
- args
-
AnyRest
geerbt von EventEmitter.__@captureRejectionSymbol@141