SharedAccessKeyAuthenticationProvider class

Paket:: azure-iot-device

Stellt ein AuthenticationProvider-Objekt bereit, das einfach mit einer Verbindungszeichenfolge erstellt werden kann und dann vom Geräteclient und Transporten zur Authentifizierung bei der Azure IoT-Hubinstanz verwendet wird.

Das SharedAccessKeyAuthenticationProvider-Objekt kümmert sich um das Erstellen freigegebener Zugriffssignaturtoken in regelmäßigen Abständen und gibt das newTokenAvailable Ereignis für die Transporte aus, um ihre Anmeldeinformationen mit der Azure IoT-Hubinstanz zu erneuern und mit der Azure IoT-Hubinstanz in Verbindung zu bleiben.

Extends: EventEmitter

Eigenschaften

type

Geerbte Eigenschaften

captureRejections	Wert: boolesch Ändere die Standardoption `captureRejections` bei allen neuen `EventEmitter` Objekten.
captureRejectionSymbol	Wert: `Symbol.for('nodejs.rejection')` Sieh dir an, wie man eine benutzerdefinierte `rejection handler`Formulierung schreibt.
defaultMaxListeners	Standardmäßig können für ein einzelnes Event ein Maximum an `10` Zuhörern registriert werden. Dieses Limit kann mit der Methode `emitter.setMaxListeners(n)` für einzelne `EventEmitter` Instanzen angepasst werden. Um den Standard für alle`EventEmitter` Instanzen zu ändern, kann die Eigenschaft `events.defaultMaxListeners` verwendet werden. Wenn dieser Wert keine positive Zahl ist, wird a `RangeError` geworfen. Seien Sie vorsichtig bei der `events.defaultMaxListeners` Einstellung, da die Änderung alle`EventEmitter` Instanzen betrifft, einschließlich derjenigen, die vor der Änderung erstellt wurden. Allerdings hat das Anrufen `emitter.setMaxListeners(n)` immer noch Vorrang vor `events.defaultMaxListeners`. Das ist keine feste Grenze. Die Instanz `EventEmitter` erlaubt es, weitere Zuhörer hinzuzufügen, gibt aber eine Trace-Warnung an stderr aus, die darauf hinweist, dass ein "mögliches EventEmitter-Speicherleck" erkannt wurde. Für jede einzelne `EventEmitter`Methode können die `emitter.getMaxListeners()` und-Methoden `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 Kommandozeilen-Flag `--trace-warnings` kann verwendet werden, um die Stack-Trace für solche Warnungen anzuzeigen. Die ausgesendete Warnung kann mit `process.on('warning')` und besitzt die zusätzlichen `emitter`, `type`, und `count` Eigenschaften besitzen, die sich auf die Instanz des Ereignisemitters, den Namen des Ereignisses und die Anzahl der angeschlossenen Zuhörer beziehen. Seine Eigenschaft `name` ist gesetzt auf `'MaxListenersExceededWarning'`.
errorMonitor	Dieses Symbol soll verwendet werden, um einen Zuhörer zu installieren, der nur Ereignisse überwacht `'error'` . Zuhörer, die mit diesem Symbol installiert sind, werden aufgerufen, bevor die regulären `'error'` Zuhörer aufgerufen werden. Die Installation eines Listeners mit diesem Symbol ändert das Verhalten nicht, sobald ein `'error'` Ereignis ausgesendet wird. Daher stürzt der Prozess trotzdem ab, wenn kein regulärer `'error'` Listener installiert ist.

Methoden

fromConnectionString(string, number, number)	Erstellt eine neue `SharedAccessKeyAuthenticationProvider` aus einer Verbindungszeichenfolge
getDeviceCredentials()
getDeviceCredentials(Callback<TransportConfig>)	Diese Methode wird von den Transporten verwendet, um die aktuellsten Geräteanmeldeinformationen in Form eines `TransportConfig`-Objekts zu erhalten.
setTokenRenewalValues(number, number)	Mit dieser Methode kann der Aufrufer neue Werte für die Authentifizierungsverlängerung festlegen. Diese Funktion wird synchron abgeschlossen, ABER führt dazu, dass Aktionen asynchron ausgeführt werden. Wenn der Anbieter bereits Tokenverlängerungen durchführt, z. B. – wenn eine Netzwerkverbindung hergestellt wurde, führt das Aufrufen dieser Funktion zu einer neuen Erneuerung am fast unmittelbaren Ablauf. Je nach Protokoll kann dies dazu führen, dass eine Verbindung getrennt und erneut verbunden wird. Wenn jedoch zurzeit keine Verlängerungen auftreten, speichern wir einfach die neuen Werte für die spätere Verwendung.
stop()	Beendet den Zeitgeber, der zum Erneuern des SAS-Tokens verwendet wird.

Geerbte Methoden

addAbortListener(AbortSignal, (event: Event) => void)	Hört sich einmal das `abort` Ereignis auf dem bereitgestellten `signal`Bildschirm an. Das Abhören des `abort` Ereignisses bei Abbruchsignalen ist unsicher und kann zu Ressourcenlecks führen, da ein anderer Dritter mit dem Signal anrufen `e.stopImmediatePropagation()`kann. Leider kann das Node.js nicht ändern, da es gegen den Webstandard verstoßen würde. Außerdem macht die ursprüngliche API es einfach, Hörer zu vergessen. Diese API ermöglicht die sichere Verwendung `AbortSignal`von s-in-Node.js-APIs, indem diese beiden Probleme gelöst werden, indem sie dem Ereignis zuhört, sodass `stopImmediatePropagation` der Listener nicht am Ausführen hindert. Gibt ein Einweg-Paket zurück, damit es leichter abgemeldet 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](); } }`
addListener<K>(string \| symbol, (args: any[]) => void)	Alias für `emitter.on(eventName, listener)`.
emit<K>(string \| symbol, AnyRest)	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
eventNames()	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) ]`
getEventListeners(EventEmitter<DefaultEventMap> \| EventTarget, string \| symbol)	Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen `eventName`zurück. Für `EventEmitter`s verhält sich dies genau wie das Anrufen `.listeners` des Emitters. Für `EventTarget`s ist dies der einzige Weg, die Ereignis-Hörer für das Ereignisziel zu erhalten. 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] ] }`
getMaxListeners()	Gibt den aktuellen Maximallistenerwert für die `EventEmitter` zurück, die entweder durch `emitter.setMaxListeners(n)` oder standardmäßig auf <xref:EventEmitter.defaultMaxListeners>festgelegt ist.
getMaxListeners(EventEmitter<DefaultEventMap> \| EventTarget)	Gibt die derzeit festgelegte maximale Hörerzahl zurück. Für `EventEmitter`s verhält sich dies genau wie das Anrufen `.getMaxListeners` des Emitters. Für `EventTarget`s ist dies der einzige Weg, die maximalen Ereignis-Listener für das Ereignisziel zu erreichen. Wenn die Anzahl der Event-Handler auf einem einzelnen EventTarget das maximale Set übersteigt, druckt das 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 }`
listenerCount(EventEmitter<DefaultEventMap>, string \| symbol)	Eine Klassenmethode, die die Anzahl der Zuhörer für das gegebene `eventName` registrierte auf dem gegebenen `emitter`zurückgibt. `import { EventEmitter, listenerCount } from 'node:events'; const myEmitter = new EventEmitter(); myEmitter.on('event', () => {}); myEmitter.on('event', () => {}); console.log(listenerCount(myEmitter, 'event')); // Prints: 2`
listenerCount<K>(string \| symbol, Function)	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.
listeners<K>(string \| symbol)	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] ]`
off<K>(string \| symbol, (args: any[]) => void)	Alias für `emitter.removeListener()`.
on(EventEmitter<DefaultEventMap>, string \| symbol, StaticEventEmitterIteratorOptions)	`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` Kehrt zurück und `AsyncIterator` iteriert `eventName` Ereignisse. Es wird geworfen, wenn der Sender `EventEmitter` aussendet `'error'`. Beim Beenden der Schleife werden alle Zuhörer entfernt. Das von jeder Iteration zurückgegebene Array `value` ist ein Array, das aus den emittierten Ereignisargumenten besteht. An `AbortSignal` kann verwendet werden, um Wartezeiten auf Veranstaltungen 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, die die Iteration beenden: `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'`
on(EventTarget, string, StaticEventEmitterIteratorOptions)
on<K>(string \| symbol, (args: any[]) => void)	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`
once(EventEmitter<DefaultEventMap>, string \| symbol, StaticEventEmitterOptions)	Erzeugt ein `Promise` Ereignis, das erfüllt wird, wenn das `EventEmitter` gegebene Ereignis ausgesendet wird, oder das abgelehnt wird, wenn das Ereignis während des `EventEmitter` Wartens ausgesendet `'error'` wird. Sie `Promise` lösen sich mit einem Array aller Argumente, die auf das gegebene Ereignis eingebracht wurden. Diese Methode ist absichtlich generisch und funktioniert mit der Webplattform EventTarget-Oberfläche , die keine Spezialereignis-Semantik`'error'` hat und das Ereignis `'error'` nicht anerkennt. `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 besondere Steuerung des Ereignisses `'error'` wird nur verwendet, wenn `events.once()` es zum Warten auf ein anderes Ereignis genutzt wird. Wenn `events.once()` verwendet wird, um auf das '`error'` -Ereignis selbst zu warten, wird es wie jede andere Art von Ereignis ohne besondere 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` An kann verwendet werden, um das Warten `AbortSignal` auf die Veranstaltung abzusagen: 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!
once(EventTarget, string, StaticEventEmitterOptions)
once<K>(string \| symbol, (args: any[]) => void)	Fügt eine einmalige`listener`-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`
prependListener<K>(string \| symbol, (args: any[]) => void)	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.
prependOnceListener<K>(string \| symbol, (args: any[]) => void)	Fügt dem beginnenden des Listenersarrays eine `listenereventName` 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.
rawListeners<K>(string \| symbol)	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');
removeAllListeners(string \| symbol)	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.
removeListener<K>(string \| symbol, (args: any[]) => void)	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 aus`emit()` 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.
setMaxListeners(number)	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.
setMaxListeners(number, (EventEmitter<DefaultEventMap> \| EventTarget)[])	`import { setMaxListeners, EventEmitter } from 'node:events'; const target = new EventTarget(); const emitter = new EventEmitter(); setMaxListeners(5, target, emitter);`
[captureRejectionSymbol]<K>(Error, string \| symbol, AnyRest)

Details zur Eigenschaft

type

type: AuthenticationType

Eigenschaftswert

AuthenticationType

Geerbte Eigenschaftsdetails

captureRejections

Wert: boolesch

Ändere die Standardoption captureRejections bei allen neuen EventEmitter Objekten.

static captureRejections: boolean

Eigenschaftswert

boolean

Geerbt von EventEmitter. FangenAblehnungen

captureRejectionSymbol

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

Sieh dir an, wie man eine benutzerdefinierte rejection handlerFormulierung schreibt.

static captureRejectionSymbol: typeof captureRejectionSymbol

Eigenschaftswert

typeof captureRejectionSymbol

Geerbt von EventEmitter.captureRerefuctionSymbol

defaultMaxListeners

Standardmäßig können für ein einzelnes Event ein Maximum an 10 Zuhörern registriert werden. Dieses Limit kann mit der Methode emitter.setMaxListeners(n) für einzelne EventEmitter Instanzen angepasst werden. Um den Standard für alleEventEmitter Instanzen zu ändern, kann die Eigenschaft events.defaultMaxListeners verwendet werden. Wenn dieser Wert keine positive Zahl ist, wird a RangeError geworfen.

Seien Sie vorsichtig bei der events.defaultMaxListeners Einstellung, da die Änderung alleEventEmitter Instanzen betrifft, einschließlich derjenigen, die vor der Änderung erstellt wurden. Allerdings hat das Anrufen emitter.setMaxListeners(n) immer noch Vorrang vor events.defaultMaxListeners.

Das ist keine feste Grenze. Die Instanz EventEmitter erlaubt es, weitere Zuhörer hinzuzufügen, gibt aber eine Trace-Warnung an stderr aus, die darauf hinweist, dass ein "mögliches EventEmitter-Speicherleck" erkannt wurde. Für jede einzelne EventEmitterMethode können die emitter.getMaxListeners() und-Methoden 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 Kommandozeilen-Flag --trace-warnings kann verwendet werden, um die Stack-Trace für solche Warnungen anzuzeigen.

Die ausgesendete Warnung kann mit process.on('warning') und besitzt die zusätzlichen emitter, type, und count Eigenschaften besitzen, die sich auf die Instanz des Ereignisemitters, den Namen des Ereignisses und die Anzahl der angeschlossenen Zuhörer beziehen. Seine Eigenschaft name ist gesetzt auf 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Eigenschaftswert

number

von EventEmitter.defaultMaxListeners geerbt

errorMonitor

Dieses Symbol soll verwendet werden, um einen Zuhörer zu installieren, der nur Ereignisse überwacht 'error' . Zuhörer, die mit diesem Symbol installiert sind, werden aufgerufen, bevor die regulären 'error' Zuhörer aufgerufen werden.

Die Installation eines Listeners mit diesem Symbol ändert das Verhalten nicht, sobald ein 'error' Ereignis ausgesendet wird. Daher stürzt der Prozess trotzdem ab, wenn kein regulärer 'error' Listener installiert ist.

static errorMonitor: typeof errorMonitor

Eigenschaftswert

typeof errorMonitor

Geerbt von EventEmitter.errorMonitor

Details zur Methode

fromConnectionString(string, number, number)

Erstellt eine neue SharedAccessKeyAuthenticationProvider aus einer Verbindungszeichenfolge

static function fromConnectionString(connectionString: string, tokenValidTimeInSeconds?: number, tokenRenewalMarginInSeconds?: number): SharedAccessKeyAuthenticationProvider

Parameter

connectionString: string

Eine Geräteverbindungszeichenfolge, die die erforderlichen Parameter für die Authentifizierung mit dem IoT-Hub enthält.

tokenValidTimeInSeconds: number

[optional] Die Anzahl der Sekunden, für die ein Token gültig sein soll.

tokenRenewalMarginInSeconds: number

[optional] Die Anzahl der Sekunden vor dem Ende des Gültigkeitszeitraums, in dem die SharedAccessKeyAuthenticationProvider das Token erneuern soll.

Gibt zurück

SharedAccessKeyAuthenticationProvider

getDeviceCredentials()

function getDeviceCredentials(): Promise<TransportConfig>

Gibt zurück

Promise<TransportConfig>

getDeviceCredentials(Callback<TransportConfig>)

Diese Methode wird von den Transporten verwendet, um die aktuellsten Geräteanmeldeinformationen in Form eines TransportConfig-Objekts zu erhalten.

function getDeviceCredentials(callback?: Callback<TransportConfig>)

Parameter

callback: Callback<TransportConfig>

optionale Funktion, die entweder mit einem Fehler oder einer Reihe von Geräteanmeldeinformationen aufgerufen wird, die zum Authentifizieren beim IoT-Hub verwendet werden können.

setTokenRenewalValues(number, number)

Mit dieser Methode kann der Aufrufer neue Werte für die Authentifizierungsverlängerung festlegen.

Diese Funktion wird synchron abgeschlossen, ABER führt dazu, dass Aktionen asynchron ausgeführt werden. Wenn der Anbieter bereits Tokenverlängerungen durchführt, z. B. – wenn eine Netzwerkverbindung hergestellt wurde, führt das Aufrufen dieser Funktion zu einer neuen Erneuerung am fast unmittelbaren Ablauf. Je nach Protokoll kann dies dazu führen, dass eine Verbindung getrennt und erneut verbunden wird. Wenn jedoch zurzeit keine Verlängerungen auftreten, speichern wir einfach die neuen Werte für die spätere Verwendung.

function setTokenRenewalValues(tokenValidTimeInSeconds: number, tokenRenewalMarginInSeconds: number)

Parameter

tokenValidTimeInSeconds: number

Die Anzahl der Sekunden, für die ein Token gültig sein soll.

tokenRenewalMarginInSeconds: number

Die Anzahl der Sekunden vor dem Ende des Gültigkeitszeitraums, in dem die SharedAccessKeyAuthenticationProvider das Token erneuern soll.

stop()

Beendet den Zeitgeber, der zum Erneuern des SAS-Tokens verwendet wird.

function stop()

Details zur geerbten Methode

addAbortListener(AbortSignal, (event: Event) => void)

Hört sich einmal das abort Ereignis auf dem bereitgestellten signalBildschirm an.

Das Abhören des abort Ereignisses bei Abbruchsignalen ist unsicher und kann zu Ressourcenlecks führen, da ein anderer Dritter mit dem Signal anrufen e.stopImmediatePropagation()kann. Leider kann das Node.js nicht ändern, da es gegen den Webstandard verstoßen würde. Außerdem macht die ursprüngliche API es einfach, Hörer zu vergessen.

Diese API ermöglicht die sichere Verwendung AbortSignalvon s-in-Node.js-APIs, indem diese beiden Probleme gelöst werden, indem sie dem Ereignis zuhört, sodass stopImmediatePropagation der Listener nicht am Ausführen hindert.

Gibt ein Einweg-Paket zurück, damit es leichter abgemeldet 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

Wegwerfer, der den Zuhörer abort entfernt.

Geerbt von EventEmitter.addAbortListener

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

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

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

Parameter

eventName: string | symbol

listener: (args: any[]) => void

Gibt zurück

SharedAccessKeyAuthenticationProvider

Geerbt von EventEmitter.addListener

emit<K>(string | symbol, AnyRest)

Ruft die einzelnen Listener synchron auf, die für das Ereignis mit dem Namen eventNameregistriert 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

eventNames()

Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter Listener registriert hat. 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

(string | symbol)[]

Geerbt von EventEmitter.eventNames

getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventNamezurück.

Für EventEmitters verhält sich dies genau wie das Anrufen .listeners des Emitters.

Für EventTargets ist dies der einzige Weg, die Ereignis-Hörer für das Ereignisziel zu erhalten. 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[]

Übernommen von EventEmitter.getEventListeners

getMaxListeners()

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

function getMaxListeners(): number

Gibt zurück

number

Geerbt von EventEmitter.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Gibt die derzeit festgelegte maximale Hörerzahl zurück.

Für EventEmitters verhält sich dies genau wie das Anrufen .getMaxListeners des Emitters.

Für EventTargets ist dies der einzige Weg, die maximalen Ereignis-Listener für das Ereignisziel zu erreichen. Wenn die Anzahl der Event-Handler auf einem einzelnen EventTarget das maximale Set übersteigt, druckt das 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

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Warnung

Diese API ist nun veraltet.

Since v3.2.0 - Use listenerCount instead.

Eine Klassenmethode, die die Anzahl der Zuhörer für das gegebene eventName registrierte auf dem gegebenen emitterzurückgibt.

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 Emitter zum Abfragen

eventName: string | symbol

Der Ereignisname

Gibt zurück

number

geerbt von EventEmitter.listenerCount

listenerCount<K>(string | symbol, Function)

Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen eventNamelauschen. 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

listeners<K>(string | symbol)

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

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

Alias für emitter.removeListener().

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

Parameter

eventName: string | symbol

listener: (args: any[]) => void

Gibt zurück

SharedAccessKeyAuthenticationProvider

von EventEmitter.off geerbt

on(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions)

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

Kehrt zurück und AsyncIterator iteriert eventName Ereignisse. Es wird geworfen, wenn der Sender EventEmitter aussendet 'error'. Beim Beenden der Schleife werden alle Zuhörer entfernt. Das von jeder Iteration zurückgegebene Array value ist ein Array, das aus den emittierten Ereignisargumenten besteht.

An AbortSignal kann verwendet werden, um Wartezeiten auf Veranstaltungen 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, die die Iteration beenden:

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>

An AsyncIterator , der Ereignisse iteriert eventName , die von den emitter

von EventEmitter.on geerbt

on(EventTarget, string, StaticEventEmitterIteratorOptions)

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

on<K>(string | symbol, (args: any[]) => void)

Fügt die listener-Funktion am Ende des Listenerarrays für das Ereignis mit dem Namen eventNamehinzu. 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 EventEmitterzurü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): SharedAccessKeyAuthenticationProvider

Parameter

eventName: string | symbol

Der Name des Ereignisses.

listener: (args: any[]) => void

Die Rückruffunktion

Gibt zurück

SharedAccessKeyAuthenticationProvider

von EventEmitter.on geerbt

once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

Erzeugt ein Promise Ereignis, das erfüllt wird, wenn das EventEmitter gegebene Ereignis ausgesendet wird, oder das abgelehnt wird, wenn das Ereignis während des EventEmitter Wartens ausgesendet 'error' wird. Sie Promise lösen sich mit einem Array aller Argumente, die auf das gegebene Ereignis eingebracht wurden.

Diese Methode ist absichtlich generisch und funktioniert mit der Webplattform EventTarget-Oberfläche , die keine Spezialereignis-Semantik'error' hat und das Ereignis 'error' nicht anerkennt.

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 besondere Steuerung des Ereignisses 'error' wird nur verwendet, wenn events.once() es zum Warten auf ein anderes Ereignis genutzt wird. Wenn events.once() verwendet wird, um auf das 'error' -Ereignis selbst zu warten, wird es wie jede andere Art von Ereignis ohne besondere 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

An kann verwendet werden, um das Warten AbortSignal auf die Veranstaltung abzusagen:

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

once(EventTarget, string, StaticEventEmitterOptions)

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

once<K>(string | symbol, (args: any[]) => void)

Fügt eine einmaligelistener-Funktion für das Ereignis mit dem Namen eventNamehinzu. 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 EventEmitterzurü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): SharedAccessKeyAuthenticationProvider

Parameter

eventName: string | symbol

Der Name des Ereignisses.

listener: (args: any[]) => void

Die Rückruffunktion

Gibt zurück

SharedAccessKeyAuthenticationProvider

von EventEmitter geerbt.once

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

Fügt die listener-Funktion dem beginnenden des Listenersarrays für das Ereignis mit dem Namen eventNamehinzu. 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 EventEmitterzurück, sodass Aufrufe verkettet werden können.

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

Parameter

eventName: string | symbol

Der Name des Ereignisses.

listener: (args: any[]) => void

Die Rückruffunktion

Gibt zurück

SharedAccessKeyAuthenticationProvider

Geerbt von EventEmitter.prependListener

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

Fügt dem beginnenden des Listenersarrays eine listenereventName 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 EventEmitterzurück, sodass Aufrufe verkettet werden können.

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

Parameter

eventName: string | symbol

Der Name des Ereignisses.

listener: (args: any[]) => void

Die Rückruffunktion

Gibt zurück

SharedAccessKeyAuthenticationProvider

geerbt von EventEmitter.prependOnceListener

rawListeners<K>(string | symbol)

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

removeAllListeners(string | symbol)

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 EventEmitterzurück, sodass Aufrufe verkettet werden können.

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

Parameter

eventName: string | symbol

Gibt zurück

SharedAccessKeyAuthenticationProvider

geerbt von EventEmitter.removeAllListeners

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

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 eventNamehinzugefü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 EventEmitterzurück, sodass Aufrufe verkettet werden können.

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

Parameter

eventName: string | symbol

listener: (args: any[]) => void

Gibt zurück

SharedAccessKeyAuthenticationProvider

Geerbt von EventEmitter.removeListener

setMaxListeners(number)

Standardmäßig druckt EventEmitters 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 EventEmitterzurück, sodass Aufrufe verkettet werden können.

function setMaxListeners(n: number): SharedAccessKeyAuthenticationProvider

Parameter

n: number

Gibt zurück

SharedAccessKeyAuthenticationProvider

Geerbt von EventEmitter.setMaxListeners

setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[])

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 Zuhörern pro EventTarget Veranstaltung.

eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[]

Null oder mehr {EventTarget}- oder {EventEmitter}-Instanzen. Wenn keine angegeben sind, n wird dies als Standardmaximum für alle neu erstellten {EventTarget}- und {EventEmitter}-Objekte gesetzt.

Geerbt von EventEmitter.setMaxListeners

[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

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

Parameter

error: Error

event: string | symbol

args: AnyRest

Geerbt von EventEmitter.__@captureRejectionSymbol@141