ModuleClient class
IoT Hub Geräteclient, der verwendet wird, um ein Gerät mit einem Azure IoT Hub zu verbinden.
Benutzer des SDK sollten eine der Factorymethoden fromConnectionString oder fromSharedAccessSignature aufrufen, um einen IoT Hub Geräteclient zu erstellen.
- Extends
-
InternalClient
Geerbte Eigenschaften
capture |
Wert: Boolesch Ändern Sie die Standardoption |
capture |
Wert: Informationen zum Schreiben eines benutzerdefinierten |
default |
Standardmäßig können maximal Gehen Sie beim Festlegen von vorsichtig vor, da sich Dies ist kein hartes Limit. 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(Callback<Disconnected>) | Schließt die Transportverbindung und zerstört die Clientressourcen. Hinweis: Nach dem Aufrufen dieser Methode kann das ModuleClient-Objekt nicht wiederverwendet werden. |
from |
Erstellt einen IoT Hub Modulclient aus der angegebenen Authentifizierungsmethode und unter Verwendung des angegebenen Transporttyps. |
from |
Erstellt einen IoT Hub Geräteclient aus dem angegebenen Verbindungszeichenfolge unter Verwendung des angegebenen Transporttyps. |
from |
|
from |
Erstellt mithilfe von Konfigurationsinformationen aus der Umgebung einen IoT Hub Modulclient. Wenn eine Umgebungsvariable namens
|
from |
Erstellt einen IoT Hub-Modulclient aus der angegebenen Shared Access Signature mithilfe des angegebenen Transporttyps. |
invoke |
|
invoke |
Ruft eine Methode auf einem nachgeschalteten Gerät oder auf einem anderen Modul auf demselben IoTEdge-Gerät auf. Beachten Sie, dass dieses Feature nur funktioniert, wenn das Modul als Teil eines IoTEdge-Geräts ausgeführt wird. |
invoke |
|
invoke |
|
on |
Registriert einen Rückruf für eine Methode mit dem Namen |
send |
|
send |
Sendet ein Ereignis an die angegebene Modulausgabe |
send |
|
send |
Sendet ein Array von Ereignissen an die angegebene Modulausgabe. |
set |
|
set |
Übergibt Optionen an das |
Geerbte Methoden
abandon(Message) | |
abandon(Message, Callback<Message |
|
add |
Lauscht einmal auf das Das Lauschen auf das Diese API ermöglicht die sichere Verwendung Gibt ein Verwerfbares zurück, damit es leichter abbestellt werden kann.
|
add |
Alias für |
complete(Message) | |
complete(Message, Callback<Message |
|
emit<K>(string | symbol, Any |
Ruft synchron jeden der Listener auf, die für das Ereignis registriert sind, in 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 Für Für
|
get |
Gibt den aktuellen max-Listenerwert für den zurück, der |
get |
Gibt die derzeit festgelegte maximale Anzahl von Listenern zurück. Für Für
|
get |
|
get |
|
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
|
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-Webplattformschnittstelle , die keine spezielle
Die spezielle Behandlung des
Ein
|
once(_DOMEvent |
|
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
|
open() | |
open(Callback<Connected>) | |
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
|
reject(Message) | |
reject(Message, Callback<Message |
|
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 das angegebene
Sobald ein Ereignis ausgegeben wurde, werden alle Listener, die zum Zeitpunkt der Ausgabe an das Ereignis angefügt sind, in der Reihenfolge aufgerufen. Dies bedeutet, dass Aufrufe
Da Listener mithilfe eines internen Arrays verwaltet werden, werden die Positionsindizes aller Listener geändert, die nach dem Entfernen des Listeners registriert wurden. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden, bedeutet jedoch, dass alle Kopien des Listenerarrays, wie sie von der 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 |
send |
|
send |
|
send |
|
send |
|
set |
Standardmäßig Gibt einen Verweis auf zurück |
set |
|
set |
Legt die Wiederholungsrichtlinie fest, die vom Client für alle Vorgänge verwendet wird. Der Standardwert ist ExponentialBackoffWithJitter. |
set |
|
set |
|
update |
|
[capture |
Geerbte Eigenschaftsdetails
captureRejections
Wert: Boolesch
Ändern Sie die Standardoption captureRejections
für alle neuen EventEmitter
Objekte.
static captureRejections: boolean
Eigenschaftswert
boolean
Geerbt von InternalClient.captureRejections
captureRejectionSymbol
Wert: Symbol.for('nodejs.rejection')
Informationen zum Schreiben eines benutzerdefinierten rejection handler
.
static captureRejectionSymbol: typeof captureRejectionSymbol
Eigenschaftswert
typeof captureRejectionSymbol
Geerbt von InternalClient.captureRejectionSymbol
defaultMaxListeners
Standardmäßig können maximal 10
Listener für ein einzelnes Ereignis registriert werden. Dieser Grenzwert kann für einzelne EventEmitter
Instanzen mit der emitter.setMaxListeners(n)
-Methode geändert werden. Um den Standardwert 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 vorsichtig vor, da sich events.defaultMaxListeners
die Änderung auf alleEventEmitter
Instanzen auswirkt, einschließlich der instanzen, die vor der Änderung erstellt wurden. Das Aufrufen emitter.setMaxListeners(n)
hat jedoch weiterhin Vorrang vor events.defaultMaxListeners
.
Dies ist kein hartes Limit. Die EventEmitter
instance ermöglicht das Hinzufügen weiterer Listener, gibt jedoch eine Ablaufverfolgungswarnung an stderr aus, die angibt, dass ein "möglicher EventEmitter-Speicherverlust" erkannt wurde. Für jede EinzelneEventEmitter
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 Stapelablaufverfolgung für solche Warnungen anzuzeigen.
Die ausgegebene Warnung kann mit process.on('warning')
und überprüft werden und verfügt über die zusätzlichen emitter
Eigenschaften , type
und count
verweist auf den Ereignisemittenter instance, den Namen des Ereignisses und die Anzahl der angefügten Listener.
Die name
-Eigenschaft ist auf 'MaxListenersExceededWarning'
festgelegt.
static defaultMaxListeners: number
Eigenschaftswert
number
Geerbt von InternalClient.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 InternalClient.errorMonitor
Details zur Methode
close()
function close(): Promise<Disconnected>
Gibt zurück
Promise<Disconnected>
close(Callback<Disconnected>)
Schließt die Transportverbindung und zerstört die Clientressourcen.
Hinweis: Nach dem Aufrufen dieser Methode kann das ModuleClient-Objekt nicht wiederverwendet werden.
function close(closeCallback?: Callback<Disconnected>)
Parameter
- closeCallback
-
Callback<Disconnected>
Optionale Funktion zum Aufrufen, sobald der Transport getrennt und der Client geschlossen wurde.
fromAuthenticationProvider(AuthenticationProvider, any)
Erstellt einen IoT Hub Modulclient aus der angegebenen Authentifizierungsmethode und unter Verwendung des angegebenen Transporttyps.
static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): ModuleClient
Parameter
- authenticationProvider
-
AuthenticationProvider
Objekt, das zum Abrufen der Authentifizierungsparameter für den IoT Hub verwendet wird.
- transportCtor
-
any
Transportprotokoll, das zum Herstellen einer Verbindung mit IoT Hub verwendet wird.
Gibt zurück
fromConnectionString(string, any)
Erstellt einen IoT Hub Geräteclient aus dem angegebenen Verbindungszeichenfolge unter Verwendung des angegebenen Transporttyps.
static function fromConnectionString(connStr: string, transportCtor: any): ModuleClient
Parameter
- connStr
-
string
Eine Verbindungszeichenfolge, die "Geräteverbindungsberechtigungen" für einen IoT Hub kapselt.
- transportCtor
-
any
Ein Transportkonstruktor.
Gibt zurück
fromEnvironment(any)
static function fromEnvironment(transportCtor: any): Promise<ModuleClient>
Parameter
- transportCtor
-
any
Gibt zurück
Promise<ModuleClient>
fromEnvironment(any, Callback<ModuleClient>)
Erstellt mithilfe von Konfigurationsinformationen aus der Umgebung einen IoT Hub Modulclient.
Wenn eine Umgebungsvariable namens EdgeHubConnectionString
oder IotHubConnectionString
vorhanden ist, wird dieser Wert verwendet, und das Verhalten ist mit dem Aufrufen fromConnectionString
der Übergabe identisch. Wenn diese Umgebungsvariablen nicht vorhanden sind, MÜSSEN die folgenden Variablen definiert werden:
- IOTEDGE_WORKLOADURI URI for iotedged's workload API
- IOTEDGE_DEVICEID Device identifier
- IOTEDGE_MODULEID Module identifier
- IOTEDGE_MODULEGENERATIONID Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME IoT Hub host name
- IOTEDGE_AUTHSCHEME Authentication scheme to use; must be "sasToken"
static function fromEnvironment(transportCtor: any, callback?: Callback<ModuleClient>)
Parameter
- transportCtor
-
any
Transportprotokoll, das zum Herstellen einer Verbindung mit IoT Hub verwendet wird.
- callback
-
Callback<ModuleClient>
Optionaler Rückruf zum Aufrufen, wenn der ModuleClient erstellt wurde oder wenn beim Erstellen des Clients ein Fehler auftritt.
fromSharedAccessSignature(string, any)
Erstellt einen IoT Hub-Modulclient aus der angegebenen Shared Access Signature mithilfe des angegebenen Transporttyps.
static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): ModuleClient
Parameter
- sharedAccessSignature
-
string
Eine freigegebene Zugriffssignatur, die die Berechtigungen "Geräteverbindung" für einen IoT Hub kapselt.
- transportCtor
-
any
Gibt zurück
invokeMethod(string, MethodParams)
function invokeMethod(deviceId: string, methodParams: MethodParams): Promise<MethodResult>
Parameter
- deviceId
-
string
- methodParams
-
MethodParams
Gibt zurück
Promise<MethodResult>
invokeMethod(string, MethodParams, Callback<MethodResult>)
Ruft eine Methode auf einem nachgeschalteten Gerät oder auf einem anderen Modul auf demselben IoTEdge-Gerät auf. Beachten Sie, dass dieses Feature nur funktioniert, wenn das Modul als Teil eines IoTEdge-Geräts ausgeführt wird.
function invokeMethod(deviceId: string, methodParams: MethodParams, callback?: Callback<MethodResult>)
Parameter
- deviceId
-
string
Zielgerätebezeichner
- methodParams
-
MethodParams
Parameter des direkten Methodenaufrufs
- callback
-
Callback<MethodResult>
optionaler Rückruf, der entweder mit einem Error-Objekt oder dem Ergebnis des Methodenaufrufs aufgerufen wird.
invokeMethod(string, string, MethodParams)
function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams): Promise<MethodResult>
Parameter
- deviceId
-
string
- moduleId
-
string
- methodParams
-
MethodParams
Gibt zurück
Promise<MethodResult>
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams, callback: Callback<MethodResult>)
Parameter
- deviceId
-
string
- moduleId
-
string
- methodParams
-
MethodParams
- callback
-
Callback<MethodResult>
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)
Registriert einen Rückruf für eine Methode mit dem Namen methodName
.
function onMethod(methodName: string, callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)
Parameter
- methodName
-
string
Name der Methode, die vom Rückruf behandelt wird
- callback
-
DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>
Funktion, die aufgerufen werden soll, wenn eine Methodenanforderung für die aufgerufene methodName
Methode empfangen wird.
sendOutputEvent(string, Message)
function sendOutputEvent(outputName: string, message: Message): Promise<MessageEnqueued>
Parameter
- outputName
-
string
- message
- Message
Gibt zurück
Promise<MessageEnqueued>
sendOutputEvent(string, Message, Callback<MessageEnqueued>)
Sendet ein Ereignis an die angegebene Modulausgabe
function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)
Parameter
- outputName
-
string
Name der Ausgabe, an die das Ereignis gesendet werden soll
- message
- Message
Nachricht, die an die angegebene Ausgabe gesendet werden soll
- callback
-
Callback<MessageEnqueued>
Optionale Funktion zum Aufrufen, wenn der Vorgang in die Warteschlange gestellt wurde.
sendOutputEventBatch(string, Message[])
function sendOutputEventBatch(outputName: string, messages: Message[]): Promise<MessageEnqueued>
Parameter
- outputName
-
string
- messages
-
Message[]
Gibt zurück
Promise<MessageEnqueued>
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)
Sendet ein Array von Ereignissen an die angegebene Modulausgabe.
function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)
Parameter
- outputName
-
string
Name der Ausgabe, an die die Ereignisse gesendet werden sollen
- messages
-
Message[]
- callback
-
Callback<MessageEnqueued>
Funktion, die aufgerufen werden soll, wenn die Vorgänge in die Warteschlange gestellt wurden.
setOptions(DeviceClientOptions)
function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>
Parameter
- options
- DeviceClientOptions
Gibt zurück
Promise<TransportConfigured>
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
Übergibt Optionen an das ModuleClient
Objekt, die zum Konfigurieren des Transports verwendet werden können.
function setOptions(options: DeviceClientOptions, done?: Callback<TransportConfigured>)
Parameter
- options
- DeviceClientOptions
- done
-
Callback<TransportConfigured>
Optionaler Rückruf, um aufzurufen, nachdem die Optionen festgelegt wurden.
Details zur geerbten Methode
abandon(Message)
function abandon(message: Message): Promise<MessageAbandoned>
Parameter
- message
- Message
Gibt zurück
Promise<MessageAbandoned>
Geerbt von InternalClient.abandon
abandon(Message, Callback<MessageAbandoned>)
function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)
Parameter
- message
- Message
- abandonCallback
-
Callback<MessageAbandoned>
Geerbt von InternalClient.abandon
addAbortListener(AbortSignal, (event: Event) => void)
Lauscht einmal auf das abort
-Ereignis auf der bereitgestellten signal
.
Das Lauschen auf das abort
Ereignis bei Abbruchsignalen ist unsicher und kann zu Ressourcenlecks führen, da ein anderer Drittanbieter mit dem Signal aufrufen e.stopImmediatePropagation()
kann. Leider kann Node.js dies nicht ändern, da es den Webstandard verletzen würde. Darüber hinaus lässt die ursprüngliche API leicht vergessen, Listener zu entfernen.
Diese API ermöglicht die sichere Verwendung AbortSignal
von s in Node.js-APIs, indem diese beiden Probleme durch Lauschen auf das Ereignis gelöst werden, sodass stopImmediatePropagation
die Ausführung des Listeners nicht verhindert wird.
Gibt ein Verwerfbares zurück, damit es 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
Verwerfbar, der den abort
Listener entfernt.
Geerbt von InternalClient.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): ModuleClient
Parameter
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Gibt zurück
Geerbt von InternalClient.addListener
complete(Message)
function complete(message: Message): Promise<MessageCompleted>
Parameter
- message
- Message
Gibt zurück
Promise<MessageCompleted>
Geerbt von InternalClient.complete
complete(Message, Callback<MessageCompleted>)
function complete(message: Message, completeCallback: Callback<MessageCompleted>)
Parameter
- message
- Message
- completeCallback
-
Callback<MessageCompleted>
Geerbt von InternalClient.complete
emit<K>(string | symbol, AnyRest)
Ruft synchron jeden der Listener auf, die für das Ereignis registriert sind, ineventName
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 InternalClient.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 InternalClient.eventNames
getEventListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget, 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 Aufrufen .listeners
auf dem Emitter.
Für EventTarget
s ist dies die einzige Möglichkeit, die Ereignislistener für das Ereignisziel abzurufen. Dies ist für Debugging- und Diagnosezwecke nützlich.
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> | _DOMEventTarget, name: string | symbol): Function[]
Parameter
- emitter
-
EventEmitter<DefaultEventMap> | _DOMEventTarget
- name
-
string | symbol
Gibt zurück
Function[]
Geerbt von InternalClient.getEventListeners
getMaxListeners()
Gibt den aktuellen max-Listenerwert für den zurück, der EventEmitter
entweder durch emitter.setMaxListeners(n)
oder standardmäßig auf defaultMaxListeners festgelegt ist.
function getMaxListeners(): number
Gibt zurück
number
Geerbt von InternalClient.getMaxListeners
getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)
Gibt die derzeit festgelegte maximale Anzahl von Listenern zurück.
Für EventEmitter
s verhält sich dies genau wie das Aufrufen .getMaxListeners
auf dem Emitter.
Für EventTarget
s ist dies die einzige Möglichkeit, die maximalen Ereignislistener für das Ereignisziel abzurufen. Wenn die Anzahl der Ereignishandler für ein einzelnes EventTarget den maximalen 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> | _DOMEventTarget): number
Parameter
- emitter
-
EventEmitter<DefaultEventMap> | _DOMEventTarget
Gibt zurück
number
Geerbt von InternalClient.getMaxListeners
getTwin()
getTwin(Callback<Twin>)
function getTwin(done: Callback<Twin>)
Parameter
- done
-
Callback<Twin>
Geerbt von InternalClient.getTwin
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 InternalClient.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, 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
- listener
-
Function
Die Ereignishandlerfunktion
Gibt zurück
number
Geerbt von InternalClient.listenerCount
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] ]
function listeners<K>(eventName: string | symbol): Function[]
Parameter
- eventName
-
string | symbol
Gibt zurück
Function[]
Geerbt von InternalClient.listeners
off<K>(string | symbol, (args: any[]) => void)
Alias für emitter.removeListener()
.
function off<K>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient
Parameter
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Gibt zurück
Geerbt von InternalClient.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 ausgegeben EventEmitter
'error'
wird. 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
- options
-
StaticEventEmitterOptions
Gibt zurück
AsyncIterableIterator<any>
, die von ausgegebenen eventName
Ereignissen durchläuft emitter
Geerbt von InternalClient.on
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 durchgeführt, um festzustellen, ob bereits listener
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. Dieemitter.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): ModuleClient
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
Geerbt von InternalClient.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-Webplattformschnittstelle , 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 InternalClient.once
once(_DOMEventTarget, string, StaticEventEmitterOptions)
static function once(emitter: _DOMEventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>
Parameter
- emitter
-
_DOMEventTarget
- eventName
-
string
- options
-
StaticEventEmitterOptions
Gibt zurück
Promise<any[]>
Geerbt von InternalClient.once
once<K>(string | symbol, (args: any[]) => void)
Fügt eine einmaligelistener
Funktion für das Ereignis mit dem Namen eventName
hinzu. 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. Dieemitter.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): ModuleClient
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
Geerbt von InternalClient.once
open()
function open(): Promise<Connected>
Gibt zurück
Promise<Connected>
Geerbt von InternalClient.open
open(Callback<Connected>)
function open(openCallback: Callback<Connected>)
Parameter
- openCallback
-
Callback<Connected>
Geerbt von InternalClient.open
prependListener<K>(string | symbol, (args: any[]) => void)
Fügt die listener
Funktion am Anfang des Listenerarrays für das Ereignis mit dem Namen eventName
hinzu. Es werden keine Überprüfungen durchgeführt, um festzustellen, ob bereits listener
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): ModuleClient
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
Geerbt von InternalClient.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
Fügt eine einmaligelistener
Funktion für das Ereignis namens 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): ModuleClient
Parameter
- eventName
-
string | symbol
Der Name des Ereignisses.
- listener
-
(args: any[]) => void
Die Rückruffunktion
Gibt zurück
Geerbt von InternalClient.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 InternalClient.rawListeners
reject(Message)
function reject(message: Message): Promise<MessageRejected>
Parameter
- message
- Message
Gibt zurück
Promise<MessageRejected>
Geerbt von InternalClient.reject
reject(Message, Callback<MessageRejected>)
function reject(message: Message, rejectCallback: Callback<MessageRejected>)
Parameter
- message
- Message
- rejectCallback
-
Callback<MessageRejected>
Geerbt von InternalClient.reject
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): ModuleClient
Parameter
- eventName
-
string | symbol
Gibt zurück
Geerbt von InternalClient.removeAllListeners
removeListener<K>(string | symbol, (args: any[]) => void)
Entfernt das angegebene listener
aus dem Listenerarray für das Ereignis namenseventName
.
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 jeden instance zu entfernen.
Sobald ein Ereignis ausgegeben wurde, werden alle Listener, die zum Zeitpunkt der Ausgabe an das Ereignis angefügt sind, in der Reihenfolge aufgerufen. Dies bedeutet, dass AufruferemoveListener()
oderremoveAllListeners()
nach dem Ausgeben und vor Abschluss der ausführung des letzten Listeners sie nicht aus deremit()
laufenden Ausführung entfernen. Nachfolgende Ereignisse verhalten sich wie erwartet.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
Da Listener mithilfe eines internen Arrays verwaltet werden, werden die Positionsindizes aller Listener geändert, die nach dem Entfernen des Listeners registriert wurden. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden, bedeutet jedoch, dass alle Kopien des Listenerarrays, wie sie von der emitter.listeners()
-Methode zurückgegeben werden, neu erstellt werden müssen.
Wenn eine einzelne Funktion mehrmals als Handler für ein einzelnes Ereignis hinzugefügt wurde (wie im folgenden Beispiel), removeListener()
wird die zuletzt hinzugefügte instance entfernt. Im Beispiel wird der once('ping')
Listener entfernt:
import { EventEmitter } from 'node:events';
const ee = new EventEmitter();
function pong() {
console.log('pong');
}
ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);
ee.emit('ping');
ee.emit('ping');
Gibt einen Verweis auf zurück EventEmitter
, damit Aufrufe verkettet werden können.
function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient
Parameter
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Gibt zurück
Geerbt von InternalClient.removeListener
sendEvent(Message)
function sendEvent(message: Message): Promise<MessageEnqueued>
Parameter
- message
- Message
Gibt zurück
Promise<MessageEnqueued>
Geerbt von InternalClient.sendEvent
sendEvent(Message, Callback<MessageEnqueued>)
function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)
Parameter
- message
- Message
- sendEventCallback
-
Callback<MessageEnqueued>
Geerbt von InternalClient.sendEvent
sendEventBatch(Message[])
function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>
Parameter
- messages
-
Message[]
Gibt zurück
Promise<MessageEnqueued>
Geerbt von InternalClient.sendEventBatch
sendEventBatch(Message[], Callback<MessageEnqueued>)
function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)
Parameter
- messages
-
Message[]
- sendEventBatchCallback
-
Callback<MessageEnqueued>
Geerbt von InternalClient.sendEventBatch
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 ein nützlicher Standard, mit dem Speicherverluste gefunden werden können. Mit emitter.setMaxListeners()
der -Methode kann der Grenzwert für diese spezifische EventEmitter
instance geändert werden. Der Wert kann aufInfinity
(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): ModuleClient
Parameter
- n
-
number
Gibt zurück
Geerbt von InternalClient.setMaxListeners
setMaxListeners(number, (EventEmitter<DefaultEventMap> | _DOMEventTarget)[])
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> | _DOMEventTarget)[])
Parameter
- n
-
number
Eine nicht negative Zahl. Die maximale Anzahl von Listenern pro EventTarget
Ereignis.
- eventTargets
-
(EventEmitter<DefaultEventMap> | _DOMEventTarget)[]
Geerbt von InternalClient.setMaxListeners
setRetryPolicy(RetryPolicy)
Legt die Wiederholungsrichtlinie fest, die vom Client für alle Vorgänge verwendet wird. Der Standardwert ist ExponentialBackoffWithJitter.
function setRetryPolicy(policy: RetryPolicy)
Parameter
- policy
-
RetryPolicy
{RetryPolicy} Die Wiederholungsrichtlinie, die für alle zukünftigen Vorgänge verwendet werden soll.
Geerbt von InternalClient.setRetryPolicy
setTransportOptions(any)
function setTransportOptions(options: any): Promise<TransportConfigured>
Parameter
- options
-
any
Gibt zurück
Promise<TransportConfigured>
Geerbt von InternalClient.setTransportOptions
setTransportOptions(any, Callback<TransportConfigured>)
function setTransportOptions(options: any, done: Callback<TransportConfigured>)
Parameter
- options
-
any
- done
-
Callback<TransportConfigured>
Geerbt von InternalClient.setTransportOptions
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)
Parameter
- sharedAccessSignature
-
string
- updateSasCallback
-
Callback<SharedAccessSignatureUpdated>
Geerbt von InternalClient.updateSharedAccessSignature
[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 InternalClient.__@captureRejectionSymbol@138