Client class
Der IoT Hub-Dienstclient wird für die Kommunikation mit Geräten über einen Azure IoT Hub verwendet. Der SDK-Benutzer ermöglicht folgendes:
- Senden von Cloud-zu-Gerät (auch als Befehle bezeichnet) an Geräte: Befehle werden auf IoT Hub in die Warteschlange gestellt und nur asynchron bereitgestellt, wenn das Gerät verbunden ist. Pro Gerät können nur 50 Befehle in die Warteschlange eingereiht werden.
- direkte Methoden auf Geräten aufrufen (dies funktioniert nur, wenn das Gerät derzeit verbunden ist: es handelt sich um eine synchrone Art der Kommunikation mit dem Gerät).
- auf Feedbackmeldungen lauschen, die von Geräten für vorherige Befehle gesendet wurden.
- auf Benachrichtigungen zum Dateiupload von Geräten lauschen.
Benutzer sollten neue Client Instanzen erstellen, indem sie eine der Factorymethoden fromConnectionString oder fromSharedAccessSignature aufrufen, um einen IoT Hub-Dienstclient zu erstellen.
- Extends
-
EventEmitter
Geerbte Eigenschaften
capture |
Wert: Boolean Ändern Sie die Standardoption |
capture |
Wert: Weitere Informationen finden Sie unter Schreiben eines benutzerdefinierten |
default |
Standardmäßig können maximal Gehen Sie beim Festlegen von Dies ist keine feste Grenze. Die
Das Die ausgegebene Warnung kann mit |
error |
Dieses Symbol soll verwendet werden, um einen Listener nur für Überwachungsereignisse Die Installation eines Listeners mit diesem Symbol ändert das Verhalten nicht, sobald ein |
Methoden
close() | |
close(Incoming |
Schließt die Verbindung mit einem IoT Hub. |
from |
Erstellt einen IoT Hub-Dienstclient aus dem angegebenen Verbindungszeichenfolge unter Verwendung des Standardtransports (Amqp) oder des im zweiten Argument angegebenen Clients. |
from |
Erstellt einen IoT Hub-Dienstclient aus der angegebenen Shared Access Signature unter Verwendung des Standardtransports (Amqp) oder des im zweiten Argument angegebenen Clients. |
from |
Erstellt einen IoT Hub-Dienstclient aus dem angegebenen Azure-TokenCredential mithilfe des Standardtransports (Amqp) oder des im zweiten Argument angegebenen Clients. |
get |
|
get |
Gibt ein AmqpReceiver-Objekt zurück, das Ereignisse ausgibt, wenn neue Feedbacknachrichten vom Client empfangen werden. |
get |
|
get |
Gibt ein AmqpReceiver-Objekt zurück, das Ereignisse ausgibt, wenn neue Dateiuploadbenachrichtigungen vom Client empfangen werden. |
invoke |
|
invoke |
Ruft eine Methode auf einem bestimmten Gerät oder Modul auf. |
invoke |
|
invoke |
|
open() | |
open(Incoming |
Öffnet die Verbindung mit einem IoT Hub. |
send(string, Message | Buffer |
|
send(string, Message | Buffer |
Sendet eine Nachricht an ein Gerät. |
set |
Legen Sie die richtlinie fest, die vom Client verwendet wird, um Netzwerkvorgänge erneut zu versuchen. |
Geerbte Methoden
add |
Lauscht einmal auf das Das Lauschen des Diese API ermöglicht die sichere Verwendung Gibt einen Einweg zurück, damit er leichter abbestellt werden kann.
|
add |
Alias für |
emit<K>(string | symbol, Any |
Ruft synchron alle Listener auf, die für das Ereignis namens Gibt zurück
|
event |
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
|
get |
Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen zurück Für Für
|
get |
Gibt den aktuellen maximalen Listenerwert für den zurück, der |
get |
Gibt die derzeit festgelegte maximale Anzahl von Listenern zurück. Für Für
|
listener |
Eine Klassenmethode, die die Anzahl der Listener für den angegebenen
|
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 zurück
|
off<K>(string | symbol, (args: any[]) => void) | Alias für |
on(Event |
Gibt ein Ein
|
on<K>(string | symbol, (args: any[]) => void) | Fügt die
Gibt einen Verweis auf zurück 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 funktioniert mit der EventTarget-Schnittstelle der Webplattform, 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 zurück Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die
|
prepend |
Fügt die
Gibt einen Verweis auf zurück |
prepend |
Fügt eine einmalige
Gibt einen Verweis auf zurück |
raw |
Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen zurück
|
remove |
Entfernt alle Listener oder die des angegebenen Es empfiehlt sich, Listener zu entfernen, die an anderer Stelle im Code hinzugefügt wurden, insbesondere wenn die Gibt einen Verweis auf zurück |
remove |
Entfernt die angegebene
Sobald ein Ereignis ausgegeben wurde, werden alle Listener, die zum Zeitpunkt der Ausgabe an das Ereignis angefügt wurden, in der Reihenfolge aufgerufen. Dies bedeutet, dass Aufrufe
Da Listener mithilfe eines internen Arrays verwaltet werden, ändern sich durch Das Aufrufen dieses Elements die Positionsindizes aller Listener, die nach dem Entfernen des Listeners registriert wurden. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden, aber es bedeutet, dass alle Kopien des Listenerarrays, wie sie von der Wenn eine einzelne Funktion mehrmals als Handler für ein einzelnes Ereignis hinzugefügt wurde (wie im folgenden Beispiel),
Gibt einen Verweis auf zurück |
set |
Standardmäßig Gibt einen Verweis auf zurück |
set |
|
[capture |
Geerbte Eigenschaftsdetails
captureRejections
Wert: Boolean
Ändern Sie die Standardoption captureRejections
für alle neuen EventEmitter
Objekte.
static captureRejections: boolean
Eigenschaftswert
boolean
Geerbt von EventEmitter.captureRejections
captureRejectionSymbol
Wert: Symbol.for('nodejs.rejection')
Weitere Informationen finden Sie unter Schreiben eines benutzerdefinierten rejection handler
.
static captureRejectionSymbol: typeof captureRejectionSymbol
Eigenschaftswert
typeof captureRejectionSymbol
Geerbt von EventEmitter.captureRejectionSymbol
defaultMaxListeners
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 die Standardeinstellung für alleEventEmitter
Instanzen zu ändern, kann die events.defaultMaxListeners
-Eigenschaft verwendet werden. Wenn dieser Wert keine positive Zahl ist, wird ein RangeError
ausgelöst.
Gehen Sie beim Festlegen von events.defaultMaxListeners
vorsichtig vor, da sich die Änderung auf alleEventEmitter
Instanzen auswirkt, einschließlich der Instanzen, die vor der Änderung erstellt wurden. Der Aufruf emitter.setMaxListeners(n)
hat jedoch weiterhin Vorrang vor events.defaultMaxListeners
.
Dies ist keine feste Grenze. Die EventEmitter
instance ermöglicht das Hinzufügen weiterer Listener, gibt aber eine Ablaufverfolgungswarnung an stderr aus, die angibt, dass ein "möglicher EventEmitter-Speicherverlust" erkannt wurde. Für jede einzelne EventEmitter
Methode können die emitter.getMaxListeners()
Methoden 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
Befehlszeilenflag kann verwendet werden, um die Stapelüberwachung für solche Warnungen anzuzeigen.
Die ausgegebene Warnung kann mit process.on('warning')
überprüft werden und weist die zusätzlichen emitter
Eigenschaften , type
und count
auf, die sich auf den Ereignis emitter instance, den Namen des Ereignisses bzw. die Anzahl der angefügten Listener beziehen.
Die - name
Eigenschaft ist auf 'MaxListenersExceededWarning'
festgelegt.
static defaultMaxListeners: number
Eigenschaftswert
number
Geerbt von EventEmitter.defaultMaxListeners
errorMonitor
Dieses Symbol soll verwendet werden, um einen Listener nur für Überwachungsereignisse 'error'
zu installieren. Listener, die mit diesem Symbol installiert werden, werden aufgerufen, bevor die regulären 'error'
Listener aufgerufen werden.
Die Installation eines Listeners mit diesem Symbol ändert das Verhalten nicht, sobald ein 'error'
Ereignis ausgegeben wird. Daher stürzt der Prozess weiterhin ab, wenn kein regulärer 'error'
Listener installiert ist.
static errorMonitor: typeof errorMonitor
Eigenschaftswert
typeof errorMonitor
Geerbt von EventEmitter.errorMonitor
Details zur Methode
close()
function close(): Promise<ResultWithIncomingMessage<Disconnected>>
Gibt zurück
Promise<ResultWithIncomingMessage<Disconnected>>
close(IncomingMessageCallback<Disconnected>)
Schließt die Verbindung mit einem IoT Hub.
function close(done?: IncomingMessageCallback<Disconnected>)
Parameter
- done
-
IncomingMessageCallback<Disconnected>
Die optionale Funktion, die aufgerufen werden soll, wenn der Vorgang abgeschlossen ist. done
wird ein Error-Objektargument übergeben, das NULL ist, wenn der Vorgang erfolgreich abgeschlossen wurde.
fromConnectionString(string, TransportCtor)
Erstellt einen IoT Hub-Dienstclient aus dem angegebenen Verbindungszeichenfolge unter Verwendung des Standardtransports (Amqp) oder des im zweiten Argument angegebenen Clients.
static function fromConnectionString(connStr: string, transportCtor?: TransportCtor): Client
Parameter
- connStr
-
string
Eine Verbindungszeichenfolge, die "Geräteverbindung"-Berechtigungen für einen IoT-Hub kapselt.
- transportCtor
- TransportCtor
Gibt zurück
fromSharedAccessSignature(string, TransportCtor)
Erstellt einen IoT Hub-Dienstclient aus der angegebenen Shared Access Signature unter Verwendung des Standardtransports (Amqp) oder des im zweiten Argument angegebenen Clients.
static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor?: TransportCtor): Client
Parameter
- sharedAccessSignature
-
string
Eine Shared Access Signature, die "Service Connect"-Berechtigungen für einen IoT-Hub kapselt.
- transportCtor
- TransportCtor
Gibt zurück
fromTokenCredential(string, TokenCredential, TransportCtor)
Erstellt einen IoT Hub-Dienstclient aus dem angegebenen Azure-TokenCredential mithilfe des Standardtransports (Amqp) oder des im zweiten Argument angegebenen Clients.
static function fromTokenCredential(hostName: string, tokenCredential: TokenCredential, transportCtor?: TransportCtor): Client
Parameter
- hostName
-
string
Hostname des Azure-Diensts.
- tokenCredential
- TokenCredential
Azure TokenCredential, die für die Authentifizierung beim Azure-Dienst verwendet werden
- transportCtor
- TransportCtor
Gibt zurück
getFeedbackReceiver()
function getFeedbackReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>
Gibt zurück
Promise<ResultWithIncomingMessage<ServiceReceiver>>
getFeedbackReceiver(IncomingMessageCallback<ServiceReceiver>)
Gibt ein AmqpReceiver-Objekt zurück, das Ereignisse ausgibt, wenn neue Feedbacknachrichten vom Client empfangen werden.
function getFeedbackReceiver(done?: IncomingMessageCallback<ServiceReceiver>)
Parameter
- done
-
IncomingMessageCallback<ServiceReceiver>
Die optionale Funktion, die aufgerufen werden soll, wenn der Vorgang abgeschlossen ist. done
wird mit zwei Argumenten aufgerufen: einem Error-Objekt (kann NULL sein) und einem AmqpReceiver-Objekt.
getFileNotificationReceiver()
function getFileNotificationReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>
Gibt zurück
Promise<ResultWithIncomingMessage<ServiceReceiver>>
getFileNotificationReceiver(IncomingMessageCallback<ServiceReceiver>)
Gibt ein AmqpReceiver-Objekt zurück, das Ereignisse ausgibt, wenn neue Dateiuploadbenachrichtigungen vom Client empfangen werden.
function getFileNotificationReceiver(done?: IncomingMessageCallback<ServiceReceiver>)
Parameter
- done
-
IncomingMessageCallback<ServiceReceiver>
Die optionale Funktion, die aufgerufen werden soll, wenn der Vorgang abgeschlossen ist. done
wird mit zwei Argumenten aufgerufen: einem Error-Objekt (kann NULL sein) und einem AmqpReceiver-Objekt.
invokeDeviceMethod(string, DeviceMethodParams)
function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>
Parameter
- deviceId
-
string
- methodParams
- DeviceMethodParams
Gibt zurück
Promise<ResultWithIncomingMessage<any>>
invokeDeviceMethod(string, DeviceMethodParams, IncomingMessageCallback<any>)
Ruft eine Methode auf einem bestimmten Gerät oder Modul auf.
function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams, done?: IncomingMessageCallback<any>)
Parameter
- deviceId
-
string
Der Bezeichner einer vorhandenen Geräteidentität.
- methodParams
- DeviceMethodParams
- done
-
IncomingMessageCallback<any>
Der optionale Rückruf, der mit dem Ergebnis der Methodenausführung aufgerufen werden soll.
invokeDeviceMethod(string, string, DeviceMethodParams)
function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>
Parameter
- deviceId
-
string
- moduleId
-
string
- methodParams
- DeviceMethodParams
Gibt zurück
Promise<ResultWithIncomingMessage<any>>
invokeDeviceMethod(string, string, DeviceMethodParams, IncomingMessageCallback<any>)
function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams, done: IncomingMessageCallback<any>)
Parameter
- deviceId
-
string
- moduleId
-
string
- methodParams
- DeviceMethodParams
- done
-
IncomingMessageCallback<any>
open()
function open(): Promise<ResultWithIncomingMessage<Connected>>
Gibt zurück
Promise<ResultWithIncomingMessage<Connected>>
open(IncomingMessageCallback<Connected>)
Öffnet die Verbindung mit einem IoT Hub.
function open(done?: IncomingMessageCallback<Connected>)
Parameter
- done
-
IncomingMessageCallback<Connected>
Die optionale Funktion, die aufgerufen werden soll, wenn der Vorgang abgeschlossen ist. done
wird ein Error-Objektargument übergeben, das NULL ist, wenn der Vorgang erfolgreich abgeschlossen wurde.
send(string, Message | BufferConvertible)
function send(deviceId: string, message: Message | BufferConvertible): Promise<ResultWithIncomingMessage<MessageEnqueued>>
Parameter
- deviceId
-
string
- message
-
Message | BufferConvertible
Gibt zurück
Promise<ResultWithIncomingMessage<MessageEnqueued>>
send(string, Message | BufferConvertible, IncomingMessageCallback<MessageEnqueued>)
Sendet eine Nachricht an ein Gerät.
function send(deviceId: string, message: Message | BufferConvertible, done?: IncomingMessageCallback<MessageEnqueued>)
Parameter
- deviceId
-
string
Der Bezeichner einer vorhandenen Geräteidentität.
- message
-
Message | BufferConvertible
Der Text der Nachricht, die an das Gerät gesendet werden soll.
Wenn message
nicht vom Typ Message ist, wird er konvertiert.
- done
-
IncomingMessageCallback<MessageEnqueued>
Die optionale Funktion, die aufgerufen werden soll, wenn der Vorgang abgeschlossen ist. done
wird mit zwei Argumenten aufgerufen: einem Error-Objekt (kann NULL sein) und einem transportspezifischen Antwortobjekt, das für die Protokollierung oder das Debuggen nützlich ist.
setRetryPolicy(RetryPolicy)
Legen Sie die richtlinie fest, die vom Client verwendet wird, um Netzwerkvorgänge erneut zu versuchen.
function setRetryPolicy(policy: RetryPolicy)
Parameter
- policy
-
RetryPolicy
Richtlinie, die für Wiederholungsvorgänge verwendet wird (z. B. Öffnen, Senden usw.). Das SDK enthält zwei "integrierte" Richtlinien: ExponentialBackoffWithJitter (Standard) und NoRetry (zum Abbrechen jeglicher Wiederholungsversuche). Der Benutzer kann auch sein eigenes Objekt übergeben, solange 2 Methoden implementiert werden: - shouldRetry(err: Error): boolean : gibt an, ob ein Vorgang basierend auf dem Fehlertyp nextRetryTimeout(retryCount: number, gedrosselt: boolescher Wert): Zahl : Gibt die Wartezeit (in Millisekunden) zurück, bevor ein Wiederholungsversuch durchgeführt wird, basierend auf der Anzahl der letzten Versuche (retryCount) und der Tatsache, dass der Fehler ein Drosselungsfehler ist oder nicht.
Details zur geerbten Methode
addAbortListener(AbortSignal, (event: Event) => void)
Lauscht einmal auf das abort
Ereignis auf dem bereitgestellten signal
.
Das Lauschen des abort
Ereignisses bei Abbruchsignalen ist unsicher und kann zu Ressourcenverlusten führen, da ein anderer Drittanbieter mit dem Signal aufrufen e.stopImmediatePropagation()
kann. Leider kann Node.js dies nicht ändern, da dies gegen den Webstandard verstoßen würde. Darüber hinaus macht es die ursprüngliche API leicht zu vergessen, Listener zu entfernen.
Diese API ermöglicht die sichere Verwendung AbortSignal
von s in Node.js-APIs, indem diese beiden Probleme gelöst werden, indem das Ereignis so abgehört wird, dass stopImmediatePropagation
der Listener nicht ausgeführt wird.
Gibt einen Einweg zurück, damit er leichter 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
addListener<K>(string | symbol, (args: any[]) => void)
Alias für emitter.on(eventName, listener)
.
function addListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parameter
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Gibt zurück
Geerbt von EventEmitter.addListener
emit<K>(string | symbol, AnyRest)
Ruft synchron alle Listener auf, die für das Ereignis namens eventName
registriert 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
- eventName
-
string | symbol
- args
-
AnyRest
Gibt zurück
boolean
Geerbt von EventEmitter.emit
eventNames()
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 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
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)
Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen zurück eventName
.
Für EventEmitter
s verhält sich dies genauso wie das Aufrufen .listeners
des Emitters.
Für EventTarget
s 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
getMaxListeners()
Gibt den aktuellen maximalen Listenerwert für den zurück, der EventEmitter
entweder standardmäßig oder emitter.setMaxListeners(n)
auf defaultMaxListeners festgelegt ist.
function getMaxListeners(): number
Gibt zurück
number
Geerbt von EventEmitter.getMaxListeners
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)
Gibt die derzeit festgelegte maximale Anzahl von Listenern zurück.
Für EventEmitter
s verhält sich dies genauso wie das Aufrufen .getMaxListeners
des Emitters.
Für EventTarget
s ist dies die einzige Möglichkeit, die maximale Ereignislistener für das Ereignisziel abzurufen. Wenn die Anzahl der Ereignishandler für ein einzelnes EventTarget den maximalen Wert ü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
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)
Warnung
Diese API ist nun veraltet.
Since v3.2.0 - Use listenerCount
instead.
Eine Klassenmethode, die die Anzahl der Listener für den angegebenen eventName
zurückgibt, der für den angegebenen emitter
registriert ist.
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 abzufragende Emitter
- 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 eventName
lauschen.
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
- eventName
-
string | symbol
Der Name des Ereignisses, auf das lauscht 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 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
- eventName
-
string | symbol
Gibt zurück
Function[]
Geerbt von EventEmitter.listeners
off<K>(string | symbol, (args: any[]) => void)
Alias für emitter.removeListener()
.
function off<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parameter
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Gibt zurück
Geerbt von EventEmitter.off
on(EventEmitter<DefaultEventMap>, string, StaticEventEmitterOptions)
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 ein AsyncIterator
zurück, das Ereignisse durchläuft eventName
. Es wird ausgelöst, wenn der EventEmitter
ausgibt 'error'
. Beim Beenden der Schleife werden alle Listener entfernt. Das value
von jeder Iteration zurückgegebene 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());
static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>
Parameter
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string
Der Name des Ereignisses, auf das lauscht wird
- options
-
StaticEventEmitterOptions
Gibt zurück
AsyncIterableIterator<any>
Eine AsyncIterator
, die ereignisse, eventName
die vom emitter
Geerbt von EventEmitter.on
on<K>(string | symbol, (args: any[]) => void)
Fügt die listener
Funktion am Ende 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.on('connection', (stream) => {
console.log('someone connected!');
});
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.prependListener()
-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.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): Client
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
Geerbt von EventEmitter.on
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)
Erstellt eine Promise
, die erfüllt wird, wenn das EventEmitter
angegebene Ereignis ausgibt, oder das abgelehnt wird, wenn das während des EventEmitter
Wartens 'error'
ausgibt.
Löst Promise
mit einem Array aller Argumente auf, die an das angegebene Ereignis ausgegeben werden.
Diese Methode ist absichtlich generisch und funktioniert mit der EventTarget-Schnittstelle der Webplattform, die keine spezielle'error'
Ereignissemantik aufweist und das 'error'
Ereignis nicht 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()
auf ein anderes Ereignis gewartet wird. Wenn events.once()
verwendet wird, um auf das Ereignis selbsterror'
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
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[]>
Geerbt von EventEmitter.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[]>
Geerbt von EventEmitter.once
once<K>(string | symbol, (args: any[]) => void)
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): Client
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
Geerbt von EventEmitter.once
prependListener<K>(string | symbol, (args: any[]) => void)
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): Client
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
Geerbt von EventEmitter.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
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): Client
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
Geerbt von EventEmitter.prependOnceListener
rawListeners<K>(string | symbol)
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
- eventName
-
string | symbol
Gibt zurück
Function[]
Geerbt von EventEmitter.rawListeners
removeAllListeners(string | symbol)
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): Client
Parameter
- eventName
-
string | symbol
Gibt zurück
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 einen instance eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für den angegebenen eventName
hinzugefügt wurde, removeListener()
muss mehrmals aufgerufen werden, um die einzelnen instance zu entfernen.
Sobald ein Ereignis ausgegeben wurde, werden alle Listener, die zum Zeitpunkt der Ausgabe an das Ereignis angefügt wurden, in der Reihenfolge aufgerufen. Dies bedeutet, dass Aufrufe removeListener()
oder removeAllListeners()
nach der Ausgabe und vor Abschluss der Ausführung des letzten Listeners sie nicht aus deremit()
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, ändern sich durch Das Aufrufen dieses Elements die Positionsindizes aller Listener, die nach dem Entfernen des Listeners registriert wurden. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden, aber es bedeutet, 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()
entfernt die zuletzt hinzugefügte instance. 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): Client
Parameter
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Gibt zurück
Geerbt von EventEmitter.removeListener
setMaxListeners(number)
Standardmäßig EventEmitter
gibt s eine Warnung aus, wenn für ein bestimmtes Ereignis mehr als 10
Listener hinzugefügt werden. Dies ist eine nützliche Standardeinstellung, mit der 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): Client
Parameter
- n
-
number
Gibt zurück
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 Listenern pro EventTarget
Ereignis.
- eventTargets
-
(EventEmitter<DefaultEventMap> | EventTarget)[]
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@115