Client class

Pakket:: azure-iot-device

IoT Hub-apparaatclient die wordt gebruikt om een apparaat te verbinden met een Azure IoT-hub.

Gebruikers van de SDK moeten een van de factory-methoden aanroepen, fromConnectionString of fromSharedAccessSignature om een IoT Hub-apparaatclient te maken.

Uitbreiding: InternalClient

Constructors

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

Overgenomen eigenschappen

captureRejections	Waarde: booleaans Verander de standaardoptie `captureRejections` op alle nieuwe `EventEmitter` objecten.
captureRejectionSymbol	Waarde: `Symbol.for('nodejs.rejection')` Zie hoe je een custom `rejection handler`schrijft.
defaultMaxListeners	Standaard kunnen maximaal luisteraars `10` voor elk evenement worden geregistreerd. Deze limiet kan voor individuele `EventEmitter` gevallen worden aangepast met behulp van de `emitter.setMaxListeners(n)` methode. Om de standaard voor alle`EventEmitter` instanties te wijzigen, kan de `events.defaultMaxListeners` eigenschap worden gebruikt. Als deze waarde geen positief getal is, wordt a `RangeError` gegooid. Wees voorzichtig bij het instellen van de instantie, `events.defaultMaxListeners` want de wijziging beïnvloedt alle`EventEmitter` instanties, inclusief die welke vóór de wijziging zijn aangemaakt. Toch heeft het aanroepen `emitter.setMaxListeners(n)` nog steeds voorrang boven `events.defaultMaxListeners`. Dit is geen harde grens. De `EventEmitter` instantie maakt het mogelijk om meer luisteraars toe te voegen, maar geeft een trace-waarschuwing uit naar stderr die aangeeft dat er een "mogelijk EventEmitter-geheugenlek" is gedetecteerd. Voor elke enkele `EventEmitter`, kunnen de `emitter.getMaxListeners()` en-methoden `emitter.setMaxListeners()` worden gebruikt om deze waarschuwing tijdelijk te vermijden: `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)); });` De `--trace-warnings` commandoregelvlag kan worden gebruikt om de stacktrace voor dergelijke waarschuwingen weer te geven. De uitgezonden waarschuwing kan worden geïnspecteerd met `process.on('warning')` en zal de extra `emitter`, `type`, en `count` eigenschappen hebben, verwijzend naar respectievelijk de gebeurtenis-emitterinstantie, de naam van het evenement en het aantal gekoppelde luisteraars. De eigenschap is `name` gezet op `'MaxListenersExceededWarning'`.
errorMonitor	Dit symbool wordt gebruikt om een luisteraar te installeren die alleen gebeurtenissen monitort `'error'` . Luisteraars die met dit symbool zijn geïnstalleerd, worden opgeroepen voordat de reguliere `'error'` luisteraars worden opgeroepen. Het installeren van een luisteraar met dit symbool verandert het gedrag niet zodra een `'error'` gebeurtenis wordt uitgezonden. Daarom crasht het proces nog steeds als er geen reguliere `'error'` luisteraar is geïnstalleerd.

Methoden

close()
close(Callback<Disconnected>)	Sluit de transportverbinding en vernietigt de clientbronnen. Opmerking: na het aanroepen van deze methode kan het clientobject niet opnieuw worden gebruikt.
fromAuthenticationProvider(AuthenticationProvider, any)	Hiermee maakt u een IoT Hub-apparaatclient op basis van de opgegeven verificatiemethode en gebruikt u het opgegeven transporttype.
fromConnectionString(string, any)	Hiermee maakt u een IoT Hub-apparaatclient op basis van de opgegeven verbindingsreeks met behulp van het opgegeven transporttype.
fromSharedAccessSignature(string, any)	Hiermee maakt u een IoT Hub-apparaatclient op basis van de opgegeven handtekening voor gedeelde toegang met behulp van het opgegeven transporttype.
getBlobSharedAccessSignature(string)
getBlobSharedAccessSignature(string, Callback<UploadParams>)	De `getBlobSharedAccessSignature` haalt het SAS-token voor het gekoppelde opslagaccount op van IoT Hub
notifyBlobUploadStatus(string, boolean, number, string)
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)	De methode `notifyBlobUploadStatus` verzendt IoT Hub het resultaat van een blobupload.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)	Registreert een callback voor een methode met de naam `methodName`.
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
uploadToBlob(string, Stream, number)
uploadToBlob(string, Stream, number, ErrorCallback)	De methode `uploadToBlob` uploadt een stream naar een blob.

Overgenomen methoden

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addAbortListener(AbortSignal, (event: Event) => void)	Luistert één keer naar het `abort` evenement op de aangeboden `signal`locatie. Het afluisteren van de `abort` gebeurtenis op abortsignalen is onveilig en kan leiden tot lekken van hulpbronnen, omdat een andere derde partij met het signaal kan bellen `e.stopImmediatePropagation()`. Helaas kan Node.js dit niet veranderen omdat het in strijd zou zijn met de webstandaard. Bovendien maakt de originele API het gemakkelijk om te vergeten luisteraars te verwijderen. Deze API maakt het veilig mogelijk om s in Node.js API's te gebruiken `AbortSignal`door deze twee problemen op te lossen door naar het event te luisteren, zodat `stopImmediatePropagation` de luisteraar niet wordt verhinderd om te draaien. Geeft een wegwerpapparaat terug zodat je je makkelijker kunt afmelden. `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 voor `emitter.on(eventName, listener)`.
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<K>(string \| symbol, AnyRest)	Roept synchroon elk van de listeners aan die zijn geregistreerd voor de gebeurtenis met de naam `eventName`, in de volgorde waarin ze zijn geregistreerd, waarbij de opgegeven argumenten aan elk item worden doorgegeven. Retourneert `true` als de gebeurtenis listeners had, anders `false`. 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()	Retourneert een matrix met de gebeurtenissen waarvoor de emitter listeners heeft geregistreerd. De waarden in de matrix zijn tekenreeksen of `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)	Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam `eventName`. Voor `EventEmitter`s gedraagt dit zich precies hetzelfde als het oproepen `.listeners` van de emitter. Voor `EventTarget`s is dit de enige manier om de event listeners voor het event target te krijgen. Dit is handig voor debugging en diagnostische doeleinden. `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()	Retourneert de huidige maximum-listenerwaarde voor de `EventEmitter` die is ingesteld door `emitter.setMaxListeners(n)` of standaard ingesteld op <xref:EventEmitter.defaultMaxListeners>.
getMaxListeners(EventEmitter<DefaultEventMap> \| EventTarget)	Geeft het momenteel ingestelde maximale aantal luisteraars terug. Voor `EventEmitter`s gedraagt dit zich precies hetzelfde als het oproepen `.getMaxListeners` van de emitter. Voor `EventTarget`s is dit de enige manier om het maximale aantal event listeners voor het event target te krijgen. Als het aantal event handlers op één EventTarget het maximale aantal overschrijdt, zal de EventTarget een waarschuwing afdrukken. `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)	Een klassemethode die het aantal luisteraars voor de gegeven `eventName` geregistreerd op de gegeven `emitter`teruggeeft. `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)	Retourneert het aantal listeners dat luistert naar de gebeurtenis met de naam `eventName`. Als `listener` wordt opgegeven, wordt geretourneerd hoe vaak de listener wordt gevonden in de lijst met listeners van de gebeurtenis.
listeners<K>(string \| symbol)	Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam `eventName`. `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 voor `emitter.removeListener()`.
on(EventEmitter<DefaultEventMap>, string \| symbol, StaticEventEmitterIteratorOptions)	`import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo')) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable here` Keert terug en `AsyncIterator` herhaalt `eventName` gebeurtenissen. Het zal gooien als de uitzendt `EventEmitter'error'`. Het verwijdert alle luisteraars bij het verlaten van de lus. De `value` door elke iteratie teruggegeven wordt een array die bestaat uit de geëmitteerde gebeurtenisargumenten. En `AbortSignal` kan worden gebruikt om wachttijd op evenementen te annuleren: 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()); Gebruik de `close` optie om een array van gebeurtenisnamen op te geven die de iteratie beëindigen: `import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); ee.emit('close'); }); for await (const event of on(ee, 'foo', { close: ['close'] })) { console.log(event); // prints ['bar'] [42] } // the loop will exit after 'close' is emitted console.log('done'); // prints 'done'`
on(EventTarget, string, StaticEventEmitterIteratorOptions)
on<K>(string \| symbol, (args: any[]) => void)	Hiermee voegt u de functie `listener` toe aan het einde van de listenersmatrix voor de gebeurtenis met de naam `eventName`. Er worden geen controles uitgevoerd om te zien of de `listener` al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van `eventName` doorgeven en `listener` leiden ertoe dat de `listener` meerdere keren wordt toegevoegd en aangeroepen. `server.on('connection', (stream) => { console.log('someone connected!'); });` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld. Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode `emitter.prependListener()` kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix. `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)	Creëert een `Promise` die wordt vervuld wanneer de `EventEmitter` gegeven gebeurtenis uitzendt, of die wordt afgewezen als de `EventEmitter` uitzendingen `'error'` tijdens het wachten wordt uitgevoerd. De `Promise` zal worden opgelost met een array van alle argumenten die aan het gegeven evenement zijn toegevoegd. Deze methode is bewust generiek en werkt met de webplatform EventTarget-interface , die geen speciale`'error'` gebeurtenissemantiek heeft en niet naar het `'error'` evenement luistert. `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); }` De speciale afhandeling van het `'error'` evenement wordt alleen gebruikt wanneer `events.once()` het wordt gebruikt om op een ander evenement te wachten. Als `events.once()` wordt gebruikt om te wachten op het '`error'` evenement zelf, dan wordt het behandeld als elk ander soort gebeurtenis zonder speciale behandeling: `import { EventEmitter, once } from 'node:events'; const ee = new EventEmitter(); once(ee, 'error') .then(([err]) => console.log('ok', err.message)) .catch((err) => console.error('error', err.message)); ee.emit('error', new Error('boom')); // Prints: ok boom` An `AbortSignal` kan worden gebruikt om het wachten op het evenement te annuleren: 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)	Hiermee voegt u een eenmalige-functie toe voor de gebeurtenis met de naam . De volgende keer dat `eventName` wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld. Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode `emitter.prependOnceListener()` kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix. `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)	Hiermee voegt u de functie `listener` toe aan de die begint van de listenersmatrix voor de gebeurtenis met de naam `eventName`. Er worden geen controles uitgevoerd om te zien of de `listener` al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van `eventName` doorgeven en `listener` leiden ertoe dat de `listener` meerdere keren wordt toegevoegd en aangeroepen. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
prependOnceListener<K>(string \| symbol, (args: any[]) => void)	Hiermee voegt u een eenmalige`listener` functie toe voor de gebeurtenis met de naam `eventName` aan de die begint van de listenersmatrix. De volgende keer dat `eventName` wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
rawListeners<K>(string \| symbol)	Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam `eventName`, inclusief eventuele wrappers (zoals die zijn gemaakt door `.once()`). 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)	Hiermee verwijdert u alle listeners of de listeners van de opgegeven `eventName`. Het is slecht om listeners te verwijderen die ergens anders in de code zijn toegevoegd, met name wanneer het `EventEmitter` exemplaar is gemaakt door een ander onderdeel of een andere module (bijvoorbeeld sockets of bestandsstromen). Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
removeListener<K>(string \| symbol, (args: any[]) => void)	Hiermee verwijdert u de opgegeven `listener` uit de listenermatrix voor de gebeurtenis met de naam `eventName`. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` verwijdert maximaal één exemplaar van een listener uit de listenermatrix. Als er meerdere keren één listener is toegevoegd aan de listenermatrix voor de opgegeven `eventName`, moet `removeListener()` meerdere keren worden aangeroepen om elk exemplaar te verwijderen. Zodra een gebeurtenis is verzonden, worden alle listeners die eraan zijn gekoppeld op het moment van verzenden in volgorde aangeroepen. Dit impliceert dat alle `removeListener()` of `removeAllListeners()` aanroepen nadat verzenden en voordat de laatste listener de uitvoering heeft voltooid, deze niet uit`emit()` worden verwijderd. Volgende gebeurtenissen gedragen zich zoals verwacht. 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 Omdat listeners worden beheerd met behulp van een interne matrix, worden de positieindexen van alle geregistreerde listener-gewijzigd nadat de listener wordt verwijderd. Dit heeft geen invloed op de volgorde waarin listeners worden aangeroepen, maar dit betekent dat kopieën van de listenermatrix die worden geretourneerd door de methode `emitter.listeners()` opnieuw moeten worden gemaakt. Wanneer één functie meerdere keren is toegevoegd als handler voor één gebeurtenis (zoals in het onderstaande voorbeeld), verwijdert `removeListener()` het laatst toegevoegde exemplaar. In het voorbeeld wordt de `once('ping')` listener verwijderd: `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');` Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)	Standaard worden `EventEmitter`s een waarschuwing afgedrukt als er meer dan `10` listeners worden toegevoegd voor een bepaalde gebeurtenis. Dit is een nuttige standaardinstelling waarmee geheugenlekken kunnen worden gevonden. Met de methode `emitter.setMaxListeners()` kan de limiet voor dit specifieke `EventEmitter` exemplaar worden gewijzigd. De waarde kan worden ingesteld op `Infinity` (of `0`) om een onbeperkt aantal listeners aan te geven. Retourneert een verwijzing naar de `EventEmitter`, zodat aanroepen kunnen worden gekoppeld.
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)	Hiermee stelt u het beleid voor opnieuw proberen dat door de client wordt gebruikt voor alle bewerkingen. De standaardwaarde is ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string \| symbol, AnyRest)

Constructordetails

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

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

Parameters

transport: DeviceTransport

Een object dat de verwachte interface van een transportobject implementeert, bijvoorbeeld Http-.

connStr: string

Een verbindingsreeks (optioneel: wanneer deze niet is opgegeven, moet updateSharedAccessSignature worden aangeroepen om het SharedAccessSignature-token rechtstreeks in te stellen).

blobUploadClient: BlobUploadClient

Een object dat een stream kan uploaden naar een blob.

fileUploadApi: FileUploadInterface

Een object dat wordt gebruikt voor communicatie met IoT Hub voor Blob Storage-gerelateerde acties.

Details van overgenomen eigenschap

captureRejections

Waarde: booleaans

Verander de standaardoptie captureRejections op alle nieuwe EventEmitter objecten.

static captureRejections: boolean

Waarde van eigenschap

boolean

Geërfd van InternClient.captureAfwijzingen

captureRejectionSymbol

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

Zie hoe je een custom rejection handlerschrijft.

static captureRejectionSymbol: typeof captureRejectionSymbol

Waarde van eigenschap

typeof captureRejectionSymbol

Geërfd van InternalClient.captureRejectionSymbol

defaultMaxListeners

Standaard kunnen maximaal luisteraars 10 voor elk evenement worden geregistreerd. Deze limiet kan voor individuele EventEmitter gevallen worden aangepast met behulp van de emitter.setMaxListeners(n) methode. Om de standaard voor alleEventEmitter instanties te wijzigen, kan de events.defaultMaxListeners eigenschap worden gebruikt. Als deze waarde geen positief getal is, wordt a RangeError gegooid.

Wees voorzichtig bij het instellen van de instantie, events.defaultMaxListeners want de wijziging beïnvloedt alleEventEmitter instanties, inclusief die welke vóór de wijziging zijn aangemaakt. Toch heeft het aanroepen emitter.setMaxListeners(n) nog steeds voorrang boven events.defaultMaxListeners.

Dit is geen harde grens. De EventEmitter instantie maakt het mogelijk om meer luisteraars toe te voegen, maar geeft een trace-waarschuwing uit naar stderr die aangeeft dat er een "mogelijk EventEmitter-geheugenlek" is gedetecteerd. Voor elke enkele EventEmitter, kunnen de emitter.getMaxListeners() en-methoden emitter.setMaxListeners() worden gebruikt om deze waarschuwing tijdelijk te vermijden:

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));
});

De --trace-warnings commandoregelvlag kan worden gebruikt om de stacktrace voor dergelijke waarschuwingen weer te geven.

De uitgezonden waarschuwing kan worden geïnspecteerd met process.on('warning') en zal de extra emitter, type, en count eigenschappen hebben, verwijzend naar respectievelijk de gebeurtenis-emitterinstantie, de naam van het evenement en het aantal gekoppelde luisteraars. De eigenschap is name gezet op 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Waarde van eigenschap

number

Geërfd van InternalClient.defaultMaxListeners

errorMonitor

Dit symbool wordt gebruikt om een luisteraar te installeren die alleen gebeurtenissen monitort 'error' . Luisteraars die met dit symbool zijn geïnstalleerd, worden opgeroepen voordat de reguliere 'error' luisteraars worden opgeroepen.

Het installeren van een luisteraar met dit symbool verandert het gedrag niet zodra een 'error' gebeurtenis wordt uitgezonden. Daarom crasht het proces nog steeds als er geen reguliere 'error' luisteraar is geïnstalleerd.

static errorMonitor: typeof errorMonitor

Waarde van eigenschap

typeof errorMonitor

Geërfd van InternalClient.errorMonitor

Methodedetails

close()

function close(): Promise<Disconnected>

Retouren

Promise<Disconnected>

close(Callback<Disconnected>)

Sluit de transportverbinding en vernietigt de clientbronnen.

Opmerking: na het aanroepen van deze methode kan het clientobject niet opnieuw worden gebruikt.

function close(closeCallback?: Callback<Disconnected>)

Parameters

closeCallback: Callback<Disconnected>

Optionele functie die moet worden aangeroepen zodra het transport is verbroken en de client is gesloten.

fromAuthenticationProvider(AuthenticationProvider, any)

Hiermee maakt u een IoT Hub-apparaatclient op basis van de opgegeven verificatiemethode en gebruikt u het opgegeven transporttype.

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

Parameters

authenticationProvider: AuthenticationProvider

Het object dat wordt gebruikt om de verificatieparameters voor de IoT-hub te verkrijgen.

transportCtor: any

Transportprotocol dat wordt gebruikt om verbinding te maken met IoT Hub.

Retouren

Client

fromConnectionString(string, any)

Hiermee maakt u een IoT Hub-apparaatclient op basis van de opgegeven verbindingsreeks met behulp van het opgegeven transporttype.

static function fromConnectionString(connStr: string, transportCtor: any): Client

Parameters

connStr: string

Een verbindingsreeks die machtigingen voor apparaatverbinding inkapselt voor een IoT-hub.

transportCtor: any

Een transportconstructor.

Retouren

Client

fromSharedAccessSignature(string, any)

Hiermee maakt u een IoT Hub-apparaatclient op basis van de opgegeven handtekening voor gedeelde toegang met behulp van het opgegeven transporttype.

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

Parameters

sharedAccessSignature: string

Een handtekening voor gedeelde toegang die machtigingen voor apparaatverbinding inkapselt voor een IoT-hub.

transportCtor: any

Retouren

Client

getBlobSharedAccessSignature(string)

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

Parameters

blobName: string

Retouren

Promise<UploadParams>

getBlobSharedAccessSignature(string, Callback<UploadParams>)

De getBlobSharedAccessSignature haalt het SAS-token voor het gekoppelde opslagaccount op van IoT Hub

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

Parameters

blobName: string

De naam die moet worden gebruikt voor de blob die wordt gemaakt met de inhoud van de stream.

callback: Callback<UploadParams>

Optionele callback om aan te roepen wanneer het uploaden is voltooid.

notifyBlobUploadStatus(string, boolean, number, string)

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

Parameters

correlationId: string

isSuccess: boolean

statusCode: number

statusDescription: string

Retouren

Promise<void>

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

De methode notifyBlobUploadStatus verzendt IoT Hub het resultaat van een blobupload.

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

Parameters

correlationId: string

Een id voor het correleren van een uploadstatus aan een specifieke blob. Gegenereerd tijdens de aanroep naar getBlobSharedAccessSignature.

isSuccess: boolean

De succes- of foutstatus van het resultaat van de opslagblobbewerking.

statusCode: number

De HTTP-statuscode die is gekoppeld aan het resultaat van de opslagblob.

statusDescription: string

De beschrijving van de HTTP-statuscode.

callback: ErrorCallback

Optionele callback om aan te roepen wanneer het uploaden is voltooid.

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

Registreert een callback voor een methode met de naam methodName.

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

Parameters

methodName: string

Naam van de methode die wordt verwerkt door de callback

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

Functie die wordt aangeroepen wanneer een methodeaanvraag voor de methode die methodName wordt genoemd, wordt ontvangen.

setOptions(DeviceClientOptions)

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

Parameters

options: DeviceClientOptions

Retouren

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

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

Parameters

options: DeviceClientOptions

done: Callback<TransportConfigured>

uploadToBlob(string, Stream, number)

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

Parameters

blobName: string

stream: Stream

streamLength: number

Retouren

Promise<void>

uploadToBlob(string, Stream, number, ErrorCallback)

De methode uploadToBlob uploadt een stream naar een blob.

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

Parameters

blobName: string

De naam die moet worden gebruikt voor de blob die wordt gemaakt met de inhoud van de stream.

stream: Stream

De gegevens naar die moeten worden geüpload naar de blob.

streamLength: number

De grootte van de gegevens naar die moet worden geüpload naar de blob.

callback: ErrorCallback

Details overgenomen methode

abandon(Message)

function abandon(message: Message): Promise<MessageAbandoned>

Parameters

message: Message

Retouren

Promise<MessageAbandoned>

overgenomen van InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>)

function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)

Parameters

message: Message

abandonCallback: Callback<MessageAbandoned>

overgenomen van InternalClient.abandon

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

Luistert één keer naar het abort evenement op de aangeboden signallocatie.

Het afluisteren van de abort gebeurtenis op abortsignalen is onveilig en kan leiden tot lekken van hulpbronnen, omdat een andere derde partij met het signaal kan bellen e.stopImmediatePropagation(). Helaas kan Node.js dit niet veranderen omdat het in strijd zou zijn met de webstandaard. Bovendien maakt de originele API het gemakkelijk om te vergeten luisteraars te verwijderen.

Deze API maakt het veilig mogelijk om s in Node.js API's te gebruiken AbortSignaldoor deze twee problemen op te lossen door naar het event te luisteren, zodat stopImmediatePropagation de luisteraar niet wordt verhinderd om te draaien.

Geeft een wegwerpapparaat terug zodat je je makkelijker kunt afmelden.

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

Parameters

signal: AbortSignal

resource: (event: Event) => void

Retouren

Disposable

Wegwerpbaar dat de abort luisteraar wegneemt.

Geërfd van InternalClient.addAbortListener

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

Alias voor emitter.on(eventName, listener).

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

Parameters

eventName: string | symbol

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

Retouren

Client

overgenomen van InternalClient.addListener

complete(Message)

function complete(message: Message): Promise<MessageCompleted>

Parameters

message: Message

Retouren

Promise<MessageCompleted>

overgenomen van InternalClient.complete

complete(Message, Callback<MessageCompleted>)

function complete(message: Message, completeCallback: Callback<MessageCompleted>)

Parameters

message: Message

completeCallback: Callback<MessageCompleted>

overgenomen van InternalClient.complete

emit<K>(string | symbol, AnyRest)

Roept synchroon elk van de listeners aan die zijn geregistreerd voor de gebeurtenis met de naam eventName, in de volgorde waarin ze zijn geregistreerd, waarbij de opgegeven argumenten aan elk item worden doorgegeven.

Retourneert true als de gebeurtenis listeners had, anders false.

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

Parameters

eventName: string | symbol

args: AnyRest

Retouren

boolean

overgenomen van InternalClient.emit

eventNames()

Retourneert een matrix met de gebeurtenissen waarvoor de emitter listeners heeft geregistreerd. De waarden in de matrix zijn tekenreeksen of 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)[]

Retouren

(string | symbol)[]

overgenomen van InternalClient.eventNames

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

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam eventName.

Voor EventEmitters gedraagt dit zich precies hetzelfde als het oproepen .listeners van de emitter.

Voor EventTargets is dit de enige manier om de event listeners voor het event target te krijgen. Dit is handig voor debugging en diagnostische doeleinden.

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[]

Parameters

emitter: EventEmitter<DefaultEventMap> | EventTarget

name: string | symbol

Retouren

Function[]

Geërfd van InternalClient.getEventListeners

getMaxListeners()

Retourneert de huidige maximum-listenerwaarde voor de EventEmitter die is ingesteld door emitter.setMaxListeners(n) of standaard ingesteld op <xref:EventEmitter.defaultMaxListeners>.

function getMaxListeners(): number

Retouren

number

overgenomen van InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Geeft het momenteel ingestelde maximale aantal luisteraars terug.

Voor EventEmitters gedraagt dit zich precies hetzelfde als het oproepen .getMaxListeners van de emitter.

Voor EventTargets is dit de enige manier om het maximale aantal event listeners voor het event target te krijgen. Als het aantal event handlers op één EventTarget het maximale aantal overschrijdt, zal de EventTarget een waarschuwing afdrukken.

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

Parameters

emitter: EventEmitter<DefaultEventMap> | EventTarget

Retouren

number

overgenomen van InternalClient.getMaxListeners

getTwin()

function getTwin(): Promise<Twin>

Retouren

Promise<Twin>

overgenomen van InternalClient.getTwin

getTwin(Callback<Twin>)

function getTwin(done: Callback<Twin>)

Parameters

done: Callback<Twin>

overgenomen van InternalClient.getTwin

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Waarschuwing

Deze API is nu afgeschaft.

Since v3.2.0 - Use listenerCount instead.

Een klassemethode die het aantal luisteraars voor de gegeven eventName geregistreerd op de gegeven emitterteruggeeft.

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

Parameters

emitter: EventEmitter<DefaultEventMap>

De emitter om te queryen

eventName: string | symbol

De gebeurtenisnaam

Retouren

number

overgenomen van InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

Retourneert het aantal listeners dat luistert naar de gebeurtenis met de naam eventName. Als listener wordt opgegeven, wordt geretourneerd hoe vaak de listener wordt gevonden in de lijst met listeners van de gebeurtenis.

function listenerCount<K>(eventName: string | symbol, listener?: Function): number

Parameters

eventName: string | symbol

De naam van de gebeurtenis die wordt geluisterd

listener: Function

De functie gebeurtenis-handler

Retouren

number

overgenomen van InternalClient.listenerCount

listeners<K>(string | symbol)

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam eventName.

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

function listeners<K>(eventName: string | symbol): Function[]

Parameters

eventName: string | symbol

Retouren

Function[]

overgenomen van InternalClient.listeners

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

Alias voor emitter.removeListener().

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

Parameters

eventName: string | symbol

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

Retouren

Client

overgenomen van InternalClient.off

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

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Keert terug en AsyncIterator herhaalt eventName gebeurtenissen. Het zal gooien als de uitzendt EventEmitter'error'. Het verwijdert alle luisteraars bij het verlaten van de lus. De value door elke iteratie teruggegeven wordt een array die bestaat uit de geëmitteerde gebeurtenisargumenten.

En AbortSignal kan worden gebruikt om wachttijd op evenementen te annuleren:

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());

Gebruik de close optie om een array van gebeurtenisnamen op te geven die de iteratie beëindigen:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parameters

emitter: EventEmitter<DefaultEventMap>

eventName: string | symbol

options: StaticEventEmitterIteratorOptions

Retouren

AsyncIterator<any[], any, any>

An AsyncIterator die gebeurtenissen herhaalt eventName die worden uitgezonden door de emitter

overgenomen van InternalClient.on

on(EventTarget, string, StaticEventEmitterIteratorOptions)

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parameters

emitter: EventTarget

eventName: string

options: StaticEventEmitterIteratorOptions

Retouren

AsyncIterator<any[], any, any>

overgenomen van InternalClient.on

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

Hiermee voegt u de functie listener toe aan het einde van de listenersmatrix voor de gebeurtenis met de naam eventName. Er worden geen controles uitgevoerd om te zien of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName doorgeven en listener leiden ertoe dat de listener meerdere keren wordt toegevoegd en aangeroepen.

server.on('connection', (stream) => {
  console.log('someone connected!');
});

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode emitter.prependListener() kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix.

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

Parameters

eventName: string | symbol

De naam van de gebeurtenis.

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

De callback-functie

Retouren

Client

overgenomen van InternalClient.on

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

Creëert een Promise die wordt vervuld wanneer de EventEmitter gegeven gebeurtenis uitzendt, of die wordt afgewezen als de EventEmitter uitzendingen 'error' tijdens het wachten wordt uitgevoerd. De Promise zal worden opgelost met een array van alle argumenten die aan het gegeven evenement zijn toegevoegd.

Deze methode is bewust generiek en werkt met de webplatform EventTarget-interface , die geen speciale'error' gebeurtenissemantiek heeft en niet naar het 'error' evenement luistert.

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);
}

De speciale afhandeling van het 'error' evenement wordt alleen gebruikt wanneer events.once() het wordt gebruikt om op een ander evenement te wachten. Als events.once() wordt gebruikt om te wachten op het 'error' evenement zelf, dan wordt het behandeld als elk ander soort gebeurtenis zonder speciale behandeling:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

An AbortSignal kan worden gebruikt om het wachten op het evenement te annuleren:

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[]>

Parameters

emitter: EventEmitter<DefaultEventMap>

eventName: string | symbol

options: StaticEventEmitterOptions

Retouren

Promise<any[]>

overgenomen van InternalClient.once

once(EventTarget, string, StaticEventEmitterOptions)

static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>

Parameters

emitter: EventTarget

eventName: string

options: StaticEventEmitterOptions

Retouren

Promise<any[]>

overgenomen van InternalClient.once

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

Hiermee voegt u een eenmalige-functie toe voor de gebeurtenis met de naam . De volgende keer dat eventName wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen.

server.once('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode emitter.prependOnceListener() kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix.

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

Parameters

eventName: string | symbol

De naam van de gebeurtenis.

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

De callback-functie

Retouren

Client

overgenomen van InternalClient.once

open()

function open(): Promise<Connected>

Retouren

Promise<Connected>

overgenomen van InternalClient.open

open(Callback<Connected>)

function open(openCallback: Callback<Connected>)

Parameters

openCallback: Callback<Connected>

overgenomen van InternalClient.open

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

Hiermee voegt u de functie listener toe aan de die begint van de listenersmatrix voor de gebeurtenis met de naam eventName. Er worden geen controles uitgevoerd om te zien of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName doorgeven en listener leiden ertoe dat de listener meerdere keren wordt toegevoegd en aangeroepen.

server.prependListener('connection', (stream) => {
  console.log('someone connected!');
});

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

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

Parameters

eventName: string | symbol

De naam van de gebeurtenis.

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

De callback-functie

Retouren

Client

overgenomen van InternalClient.prependListener

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

Hiermee voegt u een eenmaligelistener functie toe voor de gebeurtenis met de naam eventName aan de die begint van de listenersmatrix. De volgende keer dat eventName wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen.

server.prependOnceListener('connection', (stream) => {
  console.log('Ah, we have our first user!');
});

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

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

Parameters

eventName: string | symbol

De naam van de gebeurtenis.

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

De callback-functie

Retouren

Client

overgenomen van InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam eventName, inclusief eventuele wrappers (zoals die zijn gemaakt door .once()).

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[]

Parameters

eventName: string | symbol

Retouren

Function[]

overgenomen van InternalClient.rawListeners

reject(Message)

function reject(message: Message): Promise<MessageRejected>

Parameters

message: Message

Retouren

Promise<MessageRejected>

overgenomen van InternalClient.reject

reject(Message, Callback<MessageRejected>)

function reject(message: Message, rejectCallback: Callback<MessageRejected>)

Parameters

message: Message

rejectCallback: Callback<MessageRejected>

overgenomen van InternalClient.reject

removeAllListeners(string | symbol)

Hiermee verwijdert u alle listeners of de listeners van de opgegeven eventName.

Het is slecht om listeners te verwijderen die ergens anders in de code zijn toegevoegd, met name wanneer het EventEmitter exemplaar is gemaakt door een ander onderdeel of een andere module (bijvoorbeeld sockets of bestandsstromen).

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

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

Parameters

eventName: string | symbol

Retouren

Client

overgenomen van InternalClient.removeAllListeners

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

Hiermee verwijdert u de opgegeven listener uit de listenermatrix voor de gebeurtenis met de naam eventName.

const callback = (stream) => {
  console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);

removeListener() verwijdert maximaal één exemplaar van een listener uit de listenermatrix. Als er meerdere keren één listener is toegevoegd aan de listenermatrix voor de opgegeven eventName, moet removeListener() meerdere keren worden aangeroepen om elk exemplaar te verwijderen.

Zodra een gebeurtenis is verzonden, worden alle listeners die eraan zijn gekoppeld op het moment van verzenden in volgorde aangeroepen. Dit impliceert dat alle removeListener() of removeAllListeners() aanroepen nadat verzenden en voordat de laatste listener de uitvoering heeft voltooid, deze niet uitemit() worden verwijderd. Volgende gebeurtenissen gedragen zich zoals verwacht.

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

Omdat listeners worden beheerd met behulp van een interne matrix, worden de positieindexen van alle geregistreerde listener-gewijzigd nadat de listener wordt verwijderd. Dit heeft geen invloed op de volgorde waarin listeners worden aangeroepen, maar dit betekent dat kopieën van de listenermatrix die worden geretourneerd door de methode emitter.listeners() opnieuw moeten worden gemaakt.

Wanneer één functie meerdere keren is toegevoegd als handler voor één gebeurtenis (zoals in het onderstaande voorbeeld), verwijdert removeListener() het laatst toegevoegde exemplaar. In het voorbeeld wordt de once('ping') listener verwijderd:

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

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

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

Parameters

eventName: string | symbol

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

Retouren

Client

overgenomen van InternalClient.removeListener

sendEvent(Message)

function sendEvent(message: Message): Promise<MessageEnqueued>

Parameters

message: Message

Retouren

Promise<MessageEnqueued>

overgenomen van InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>)

function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)

Parameters

message: Message

sendEventCallback: Callback<MessageEnqueued>

overgenomen van InternalClient.sendEvent

sendEventBatch(Message[])

function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>

Parameters

messages: Message[]

Retouren

Promise<MessageEnqueued>

overgenomen van InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>)

function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)

Parameters

messages: Message[]

sendEventBatchCallback: Callback<MessageEnqueued>

overgenomen van InternalClient.sendEventBatch

setMaxListeners(number)

Standaard worden EventEmitters een waarschuwing afgedrukt als er meer dan 10 listeners worden toegevoegd voor een bepaalde gebeurtenis. Dit is een nuttige standaardinstelling waarmee geheugenlekken kunnen worden gevonden. Met de methode emitter.setMaxListeners() kan de limiet voor dit specifieke EventEmitter exemplaar worden gewijzigd. De waarde kan worden ingesteld op Infinity (of 0) om een onbeperkt aantal listeners aan te geven.

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

function setMaxListeners(n: number): Client

Parameters

n: number

Retouren

Client

overgenomen van 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)[])

Parameters

n: number

Een niet-negatief getal. Het maximale aantal luisteraars per EventTarget evenement.

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

Nul of meer {EventTarget}- of {EventEmitter}-instanties. Als er geen zijn gespecificeerd, n wordt deze ingesteld als de standaard max voor alle nieuw aangemaakte {EventTarget}- en {EventEmitter}-objecten.

overgenomen van InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Hiermee stelt u het beleid voor opnieuw proberen dat door de client wordt gebruikt voor alle bewerkingen. De standaardwaarde is ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parameters

policy: RetryPolicy

{RetryPolicy} Het beleid voor opnieuw proberen dat moet worden gebruikt voor alle toekomstige bewerkingen.

overgenomen van InternalClient.setRetryPolicy

setTransportOptions(any)

function setTransportOptions(options: any): Promise<TransportConfigured>

Parameters

options: any

Retouren

Promise<TransportConfigured>

overgenomen van InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>)

function setTransportOptions(options: any, done: Callback<TransportConfigured>)

Parameters

options: any

done: Callback<TransportConfigured>

overgenomen van InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)

function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)

Parameters

sharedAccessSignature: string

updateSasCallback: Callback<SharedAccessSignatureUpdated>

overgenomen van InternalClient.updateSharedAccessSignature

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

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

Parameters

error: Error

event: string | symbol

args: AnyRest

Geërfd van InternalClient.__@captureRejectionSymbol@141