Client class

Referenz

Paket:: azure-iot-device

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

Konstruktoren

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

Geerbte Eigenschaften

captureRejections	Wert: Boolean Ändern Sie die Standardoption `captureRejections` für alle neuen `EventEmitter` Objekte.
captureRejectionSymbol	Wert: `Symbol.for('nodejs.rejection')` Weitere Informationen finden Sie unter Schreiben eines benutzerdefinierten `rejection handler`.
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 alle`EventEmitter` 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 alle`EventEmitter` 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.
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.

Methoden

close()
close(Callback<Disconnected>)	Schließt die Transportverbindung und zerstört die Clientressourcen. Hinweis: Nach dem Aufrufen dieser Methode kann das Client-Objekt nicht wiederverwendet werden.
fromAuthenticationProvider(AuthenticationProvider, any)	Erstellt einen IoT Hub Geräteclient aus der angegebenen Authentifizierungsmethode und unter Verwendung des angegebenen Transporttyps.
fromConnectionString(string, any)	Erstellt einen IoT Hub Geräteclient aus dem angegebenen Verbindungszeichenfolge unter Verwendung des angegebenen Transporttyps.
fromSharedAccessSignature(string, any)	Erstellt einen IoT Hub Geräteclient aus der angegebenen Shared Access Signature unter Verwendung des angegebenen Transporttyps.
getBlobSharedAccessSignature(string)
getBlobSharedAccessSignature(string, Callback<UploadParams>)	Ruft `getBlobSharedAccessSignature` das SAS-Token des verknüpften Speicherkontos aus IoT Hub
notifyBlobUploadStatus(string, boolean, number, string)
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)	Die `notifyBlobUploadStatus` -Methode sendet IoT Hub das Ergebnis eines Blobuploads.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)	Registriert einen Rückruf für eine Methode namens `methodName`.
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
uploadToBlob(string, Stream, number)
uploadToBlob(string, Stream, number, ErrorCallback)	Die `uploadToBlob` -Methode lädt einen Stream in ein Blob hoch.

Geerbte Methoden

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
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](); } }`
addListener<K>(string \| symbol, (args: any[]) => void)	Alias für `emitter.on(eventName, listener)`.
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<K>(string \| symbol, AnyRest)	Ruft synchron alle listener auf, die für das Ereignis mit dem Namen `eventName`registriert sind, in der Reihenfolge, in der sie registriert wurden, und übergibt jeweils die angegebenen Argumente. 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
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) ]`
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 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] ] }`
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.
getMaxListeners(EventEmitter<DefaultEventMap> \| EventTarget)	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 }`
getTwin()
getTwin(Callback<Twin>)
listenerCount(EventEmitter<DefaultEventMap>, string \| symbol)	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`
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, 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());
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. 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`
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 selbst`error'` 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!
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 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`
open()
open(Callback<Connected>)
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.
prependOnceListener<K>(string \| symbol, (args: any[]) => void)	Fügt eine einmalige`listener` 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.
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()`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');
reject(Message)
reject(Message, Callback<MessageRejected>)
removeAllListeners(string \| symbol)	Entfernt alle Listener oder die des angegebenen `eventName`. Es ist eine schlechte Praxis, 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.
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 der`emit()` 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.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
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.
setMaxListeners(number, (EventEmitter<DefaultEventMap> \| EventTarget)[])	`import { setMaxListeners, EventEmitter } from 'node:events'; const target = new EventTarget(); const emitter = new EventEmitter(); setMaxListeners(5, target, emitter);`
setRetryPolicy(RetryPolicy)	Legt die Wiederholungsrichtlinie fest, die vom Client für alle Vorgänge verwendet wird. Der Standardwert ist ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string \| symbol, AnyRest)

Details zum Konstruktor

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

new Client(transport: DeviceTransport, connStr?: string, blobUploadClient?: BlobUploadClient, fileUploadApi?: FileUploadInterface)

Parameter

transport: DeviceTransport

Ein Objekt, das die von einem Transportobjekt erwartete Schnittstelle implementiert, z. B. HTTP.

connStr: string

Ein Verbindungszeichenfolge (optional: Wenn nicht angegeben, muss updateSharedAccessSignature aufgerufen werden, um das SharedAccessSignature-Token direkt festzulegen).

blobUploadClient: BlobUploadClient

Ein Objekt, das einen Stream in ein Blob hochladen kann.

fileUploadApi: FileUploadInterface

Ein Objekt, das für die Kommunikation mit IoT Hub für Blob Storage-bezogene Aktionen verwendet wird.

Geerbte Eigenschaftsdetails

captureRejections

Wert: Boolean

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

Weitere Informationen finden Sie unter 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 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 EventEmitterMethode 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 emitterEigenschaften , typeund 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 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 Client-Objekt nicht wiederverwendet werden.

function close(closeCallback?: Callback<Disconnected>)

Parameter

closeCallback: Callback<Disconnected>

Optionale Funktion, die aufgerufen werden kann, sobald die Verbindung zwischen dem Transport getrennt und der Client geschlossen wird.

fromAuthenticationProvider(AuthenticationProvider, any)

Erstellt einen IoT Hub Geräteclient aus der angegebenen Authentifizierungsmethode und unter Verwendung des angegebenen Transporttyps.

static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): Client

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

Client

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

Parameter

connStr: string

Eine Verbindungszeichenfolge, die "Geräteverbindung"-Berechtigungen für einen IoT-Hub kapselt.

transportCtor: any

Ein Transportkonstruktor.

Gibt zurück

Client

fromSharedAccessSignature(string, any)

Erstellt einen IoT Hub Geräteclient aus der angegebenen Shared Access Signature unter Verwendung des angegebenen Transporttyps.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): Client

Parameter

sharedAccessSignature: string

Eine Shared Access Signature, die "Geräteverbindung"-Berechtigungen für einen IoT-Hub kapselt.

transportCtor: any

Gibt zurück

Client

getBlobSharedAccessSignature(string)

function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>

Parameter

blobName: string

Gibt zurück

Promise<UploadParams>

getBlobSharedAccessSignature(string, Callback<UploadParams>)

Ruft getBlobSharedAccessSignature das SAS-Token des verknüpften Speicherkontos aus IoT Hub

function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)

Parameter

blobName: string

Der Name, der für das Blob verwendet werden soll, das mit dem Inhalt des Streams erstellt wird.

callback: Callback<UploadParams>

Optionaler Rückruf, um aufzurufen, wenn der Upload abgeschlossen ist.

notifyBlobUploadStatus(string, boolean, number, string)

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string): Promise<void>

Parameter

correlationId: string

isSuccess: boolean

statusCode: number

statusDescription: string

Gibt zurück

Promise<void>

notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)

Die notifyBlobUploadStatus -Methode sendet IoT Hub das Ergebnis eines Blobuploads.

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)

Parameter

correlationId: string

Eine ID zum Korrelieren eines Upload-status zu einem bestimmten Blob. Wird während des Aufrufs von getBlobSharedAccessSignaturegeneriert.

isSuccess: boolean

Der Erfolg oder Fehler status aus dem Ergebnis des Speicherblobvorgangs.

statusCode: number

Der HTTP-status Code, der dem Ergebnis des Speicherblobs zugeordnet ist.

statusDescription: string

Die Beschreibung des HTTP-status Codes.

callback: ErrorCallback

Optionaler Rückruf, um aufzurufen, wenn der Upload abgeschlossen ist.

onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Registriert einen Rückruf für eine Methode namens methodName.

function onDeviceMethod(methodName: string, callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Parameter

methodName: string

Name der Methode, die vom Rückruf behandelt wird

callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void

Funktion, die immer dann aufgerufen werden soll, wenn eine Methodenanforderung für die aufgerufene methodName Methode empfangen wird.

setOptions(DeviceClientOptions)

function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>

Parameter

options: DeviceClientOptions

Gibt zurück

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

function setOptions(options: DeviceClientOptions, done: Callback<TransportConfigured>)

Parameter

options: DeviceClientOptions

done: Callback<TransportConfigured>

uploadToBlob(string, Stream, number)

function uploadToBlob(blobName: string, stream: Stream, streamLength: number): Promise<void>

Parameter

blobName: string

stream: Stream

streamLength: number

Gibt zurück

Promise<void>

uploadToBlob(string, Stream, number, ErrorCallback)

Die uploadToBlob -Methode lädt einen Stream in ein Blob hoch.

function uploadToBlob(blobName: string, stream: Stream, streamLength: number, callback: ErrorCallback)

Parameter

blobName: string

Der Name, der für das Blob verwendet werden soll, das mit dem Inhalt des Streams erstellt wird.

stream: Stream

Die Daten, die in das Blob hochgeladen werden sollen.

streamLength: number

Die Größe der Daten, die in das Blob hochgeladen werden sollen.

callback: ErrorCallback

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 AbortSignalvon 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): Client

Parameter

eventName: string | symbol

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

Gibt zurück

Client

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 alle listener auf, die für das Ereignis mit dem Namen eventNameregistriert sind, in der Reihenfolge, in der sie registriert wurden, und übergibt jeweils die angegebenen Argumente.

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 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 InternalClient.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 Aufrufen .listeners auf dem Emitter.

Für EventTargets 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> | EventTarget, name: string | symbol): Function[]

Parameter

emitter: EventEmitter<DefaultEventMap> | EventTarget

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> | EventTarget)

Gibt die derzeit festgelegte maximale Anzahl von Listenern zurück.

Für EventEmitters verhält sich dies genau wie das Aufrufen .getMaxListeners auf dem Emitter.

Für EventTargets 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> | EventTarget): number

Parameter

emitter: EventEmitter<DefaultEventMap> | EventTarget

Gibt zurück

number

Geerbt von InternalClient.getMaxListeners

getTwin()

function getTwin(): Promise<Twin>

Gibt zurück

Promise<Twin>

Geerbt von InternalClient.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 emitterregistriert 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 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 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 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[]

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

Parameter

eventName: string | symbol

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

Gibt zurück

Client

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>

Ein AsyncIterator , der vom ausgegebenen Ereignis durchläuft eventNameemitter

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 eventNamehinzu. 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. 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

Client

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(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 InternalClient.once

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

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

Client

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 eventNamehinzu. 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): Client

Parameter

eventName: string | symbol

Der Name des Ereignisses.

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

Die Rückruffunktion

Gibt zurück

Client

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

Parameter

eventName: string | symbol

Der Name des Ereignisses.

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

Die Rückruffunktion

Gibt zurück

Client

Geerbt von InternalClient.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()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 ist eine schlechte Praxis, 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

Client

Geerbt von InternalClient.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 eventNamehinzugefü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

Client

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 EventEmittergibt 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

Client

Geerbt von InternalClient.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 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

Share via

Client class

Konstruktoren

Geerbte Eigenschaften

Methoden

Geerbte Methoden

Details zum Konstruktor

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

Parameter

Geerbte Eigenschaftsdetails

captureRejections

Eigenschaftswert

captureRejectionSymbol

Eigenschaftswert

defaultMaxListeners

Eigenschaftswert

errorMonitor

Eigenschaftswert

Details zur Methode

close()

Gibt zurück

close(Callback<Disconnected>)

Parameter

fromAuthenticationProvider(AuthenticationProvider, any)

Parameter

Gibt zurück

fromConnectionString(string, any)

Parameter

Gibt zurück

fromSharedAccessSignature(string, any)

Parameter

Gibt zurück

getBlobSharedAccessSignature(string)

Parameter

Gibt zurück

getBlobSharedAccessSignature(string, Callback<UploadParams>)

Parameter

notifyBlobUploadStatus(string, boolean, number, string)

Parameter

Gibt zurück

notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)

Parameter

onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Parameter

setOptions(DeviceClientOptions)

Parameter

Gibt zurück

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Parameter

uploadToBlob(string, Stream, number)

Parameter

Gibt zurück

uploadToBlob(string, Stream, number, ErrorCallback)

Parameter

Details zur geerbten Methode

abandon(Message)

Parameter

Gibt zurück

abandon(Message, Callback<MessageAbandoned>)

Parameter

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

Parameter

Gibt zurück

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

Parameter

Gibt zurück

complete(Message)

Parameter

Gibt zurück

complete(Message, Callback<MessageCompleted>)

Parameter

emit<K>(string | symbol, AnyRest)

Parameter

Gibt zurück

eventNames()

Gibt zurück

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

Parameter

Gibt zurück

getMaxListeners()