ModuleClient class

Referens

Paket:: azure-iot-device

IoT Hub-enhetsklient som används för att ansluta en enhet till en Azure IoT-hubb.

Användare av SDK:n bör anropa någon av fabriksmetoderna, frånConnectionString eller frånSharedAccessSignature för att skapa en IoT Hub-enhetsklient.

Extends: InternalClient

Ärvda egenskaper

captureRejections	Värde: booleska Ändra standardalternativet `captureRejections` för alla nya `EventEmitter` objekt.
captureRejectionSymbol	Värde: `Symbol.for('nodejs.rejection')` Se hur du skriver en anpassad `rejection handler`.
defaultMaxListeners	Som standard kan maximalt `10` lyssnare registreras för en enskild händelse. Den här gränsen kan ändras för enskilda `EventEmitter`-instanser med hjälp av metoden `emitter.setMaxListeners(n)`. Om du vill ändra standardvärdet för alla`EventEmitter` instanser kan egenskapen `events.defaultMaxListeners` användas. Om det här värdet inte är ett positivt tal genereras en `RangeError`. Var försiktig när du anger `events.defaultMaxListeners` eftersom ändringen påverkar alla`EventEmitter` instanser, inklusive de som skapades innan ändringen gjordes. Men att anropa `emitter.setMaxListeners(n)` har fortfarande företräde framför `events.defaultMaxListeners`. Detta är inte en hård gräns. Den `EventEmitter` instansen gör att fler lyssnare kan läggas till, men skickar en spårningsvarning till stderr som anger att en "möjlig EventEmitter-minnesläcka" har identifierats. För en enskild `EventEmitter`kan metoderna `emitter.getMaxListeners()` och `emitter.setMaxListeners()` användas för att tillfälligt undvika den här varningen: `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)); });` Den `--trace-warnings` kommandoradsflaggan kan användas för att visa stackspårningen för sådana varningar. Den avgivna varningen kan inspekteras med `process.on('warning')` och har ytterligare egenskaper `emitter`, `type`och `count`, med hänvisning till händelseemitterarens instans, händelsens namn respektive antalet anslutna lyssnare. Egenskapen `name` är inställd på `'MaxListenersExceededWarning'`.
errorMonitor	Denna symbol ska användas för att installera en lyssnare för att endast övervaka `'error'` händelser. Lyssnare som installeras med den här symbolen anropas innan de vanliga `'error'` lyssnarna anropas. När du installerar en lyssnare med den här symbolen ändras inte beteendet när en `'error'` händelse har genererats. Därför kraschar processen fortfarande om ingen vanlig `'error'` lyssnaren är installerad.

Metoder

close()
close(Callback<Disconnected>)	Stänger transportanslutningen och förstör klientresurserna. Obs! När du har anropat den här metoden kan inte ModuleClient-objektet återanvändas.
fromAuthenticationProvider(AuthenticationProvider, any)	Skapar en IoT Hub-modulklient från den angivna autentiseringsmetoden och använder den angivna transporttypen.
fromConnectionString(string, any)	Skapar en IoT Hub-enhetsklient från den angivna anslutningssträngen med den angivna transporttypen.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)	Skapar en IoT Hub-modulklient med hjälp av konfigurationsinformation från miljön. Om det finns en miljövariabel med namnet `EdgeHubConnectionString` eller `IotHubConnectionString` används det värdet och beteendet är identiskt med att anropa `fromConnectionString` skicka in det. Om dessa miljövariabler inte finns måste följande variabler definieras: `- IOTEDGE_WORKLOADURI URI for iotedged's workload API - IOTEDGE_DEVICEID Device identifier - IOTEDGE_MODULEID Module identifier - IOTEDGE_MODULEGENERATIONID Module generation identifier - IOTEDGE_IOTHUBHOSTNAME IoT Hub host name - IOTEDGE_AUTHSCHEME Authentication scheme to use; must be "sasToken"`
fromSharedAccessSignature(string, any)	Skapar en IoT Hub-modulklient från den angivna signaturen för delad åtkomst med den angivna transporttypen.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)	Anropar en metod på en nedströmsenhet eller på en annan modul på samma IoTEdge-enhet. Observera att den här funktionen endast fungerar när modulen körs som en del av en IoTEdge-enhet.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)	Registrerar ett återanrop för en metod med namnet `methodName`.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)	Skickar en händelse till den angivna modulens utdata
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)	Skickar en matris med händelser till den angivna modulens utdata
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)	Skickar alternativ till det `ModuleClient` objekt som kan användas för att konfigurera transporten.

Ärvda metoder

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addAbortListener(AbortSignal, (event: Event) => void)	Lyssnar en gång på händelsen `abort` på den angivna `signal`. Att lyssna på den `abort` händelsen vid avbrutna signaler är osäkert och kan leda till resursläckor eftersom en annan tredje part med signalen kan anropa `e.stopImmediatePropagation()`. Tyvärr kan Node.js inte ändra detta eftersom det skulle bryta mot webbstandarden. Dessutom gör det ursprungliga API:et det enkelt att glömma att ta bort lyssnare. Med det här API:et kan du på ett säkert sätt använda `AbortSignal`i Node.js API:er genom att lösa dessa två problem genom att lyssna på händelsen så att `stopImmediatePropagation` inte hindrar lyssnaren från att köras. Returnerar en disponibel fil så att den kan avsluta prenumerationen på ett enklare sätt. `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)	Anropar synkront var och en av lyssnarna som registrerats för händelsen med namnet `eventName`, i den ordning de registrerades och skickar de angivna argumenten till var och en. Returnerar `true` om händelsen hade lyssnare, `false` annars. 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()	Returnerar en matris som visar de händelser som sändaren har registrerade lyssnare för. Värdena i matrisen är strängar eller `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)	Returnerar en kopia av matrisen med lyssnare för händelsen med namnet `eventName`. För `EventEmitter`fungerar detta exakt som att anropa `.listeners` på emittern. För `EventTarget`är det här det enda sättet att hämta händelselyssnare för händelsemålet. Detta är användbart för felsökning och diagnostik. `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()	Returnerar det aktuella maximala lyssnarvärdet för `EventEmitter` som antingen anges av `emitter.setMaxListeners(n)` eller som standard till defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> \| EventTarget)	Returnerar den för närvarande angivna maximala mängden lyssnare. För `EventEmitter`fungerar detta exakt som att anropa `.getMaxListeners` på emittern. För `EventTarget`är det här det enda sättet att få maximalt antal händelselyssnare för händelsemålet. Om antalet händelsehanterare på en enskild EventTarget överskrider maxuppsättningen skriver EventTarget ut en varning. `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)	En klassmetod som returnerar antalet lyssnare för den angivna `eventName` som registrerats på den angivna `emitter`. `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)	Returnerar antalet lyssnare som lyssnar efter händelsen med namnet `eventName`. Om `listener` anges returneras hur många gånger lyssnaren finns i listan över lyssnarna för händelsen.
listeners<K>(string \| symbol)	Returnerar en kopia av matrisen med lyssnare för händelsen med namnet `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 för `emitter.removeListener()`.
on(EventEmitter<DefaultEventMap>, string \| symbol, StaticEventEmitterIteratorOptions)	`import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo')) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable here` Returnerar en `AsyncIterator` som itererar `eventName` händelser. Det utlöser om `EventEmitter` genererar `'error'`. Den tar bort alla lyssnare när du avslutar loopen. Den `value` som returneras av varje iteration är en matris som består av de utgivna händelseargumenten. En `AbortSignal` kan användas för att avbryta väntan på händelser: 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()); Använd alternativet `close` för att ange en matris med händelsenamn som avslutar iterationen: `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)	Lägger till funktionen `listener` i slutet av lyssnarmatrisen för händelsen med namnet `eventName`. Inga kontroller görs för att se om `listener` redan har lagts till. Flera anrop som skickar samma kombination av `eventName` och `listener` resulterar i att `listener` läggs till och anropas flera gånger. `server.on('connection', (stream) => { console.log('someone connected!'); });` Returnerar en referens till `EventEmitter`, så att anrop kan länkas. Som standard anropas händelselyssnare i den ordning de läggs till. Metoden `emitter.prependListener()` kan användas som ett alternativ för att lägga till händelselyssnaren i början av lyssnarmatrisen. `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)	Skapar en `Promise` som uppfylls när `EventEmitter` genererar den angivna händelsen eller som avvisas om `EventEmitter` genererar `'error'` i väntan. Den `Promise` löser med en matris med alla argument som genereras till den angivna händelsen. Den här metoden är avsiktligt generisk och fungerar med webbplattformen EventTarget-gränssnittet, som inte har någon särskild`'error'` händelsesemantik och inte lyssnar på `'error'` händelsen. `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); }` Den särskilda hanteringen av händelsen `'error'` används bara när `events.once()` används för att vänta på en annan händelse. Om `events.once()` används för att vänta på själva händelsen "`error'` behandlas den som någon annan typ av händelse utan särskild hantering: `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` En `AbortSignal` kan användas för att avbryta väntan på händelsen: 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)	Lägger till en engångsfunktion för`listener` för händelsen med namnet `eventName`. Nästa gång `eventName` utlöses tas lyssnaren bort och anropas sedan. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` Returnerar en referens till `EventEmitter`, så att anrop kan länkas. Som standard anropas händelselyssnare i den ordning de läggs till. Metoden `emitter.prependOnceListener()` kan användas som ett alternativ för att lägga till händelselyssnaren i början av lyssnarmatrisen. `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)	Lägger till funktionen `listener` i början av lyssnarmatrisen för händelsen med namnet `eventName`. Inga kontroller görs för att se om `listener` redan har lagts till. Flera anrop som skickar samma kombination av `eventName` och `listener` resulterar i att `listener` läggs till och anropas flera gånger. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
prependOnceListener<K>(string \| symbol, (args: any[]) => void)	Lägger till en engångsfunktion för`listener` för händelsen med namnet `eventName` till början av lyssnarmatrisen. Nästa gång `eventName` utlöses tas lyssnaren bort och anropas sedan. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
rawListeners<K>(string \| symbol)	Returnerar en kopia av matrisen med lyssnare för händelsen med namnet `eventName`, inklusive eventuella omslutningar (till exempel de som skapats av `.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)	Tar bort alla lyssnare eller de som anges `eventName`. Det är dålig praxis att ta bort lyssnare som lagts till någon annanstans i koden, särskilt när den `EventEmitter` instansen skapades av någon annan komponent eller modul (t.ex. sockets eller filströmmar). Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
removeListener<K>(string \| symbol, (args: any[]) => void)	Tar bort den angivna `listener` från lyssnarmatrisen för händelsen med namnet `eventName`. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` tar högst bort en instans av en lyssnare från lyssnarmatrisen. Om en enskild lyssnare har lagts till flera gånger i lyssnarmatrisen för den angivna `eventName`måste `removeListener()` anropas flera gånger för att ta bort varje instans. När en händelse har genererats anropas alla lyssnare som är anslutna till den vid tidpunkten för avsändande i ordning. Detta innebär att alla `removeListener()`- eller `removeAllListeners()`-anrop efter avger och innan den senaste lyssnaren slutför körningen inte tar bort dem från`emit()` pågår. Efterföljande händelser fungerar som förväntat. 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 Eftersom lyssnare hanteras med hjälp av en intern matris ändras positionsindexen för alla lyssnare som registrerats när lyssnaren tas bort. Detta påverkar inte i vilken ordning lyssnare anropas, men det innebär att alla kopior av lyssnarmatrisen som returneras av metoden `emitter.listeners()` måste återskapas. När en enskild funktion har lagts till som hanterare flera gånger för en enskild händelse (som i exemplet nedan) tar `removeListener()` bort den senast tillagda instansen. I exemplet tas `once('ping')` lyssnaren bort: `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');` Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)	Som standard skriver `EventEmitter`ut en varning om fler än `10` lyssnare läggs till för en viss händelse. Det här är ett användbart standardvärde som hjälper dig att hitta minnesläckor. Med metoden `emitter.setMaxListeners()` kan gränsen ändras för den här specifika `EventEmitter` instansen. Värdet kan anges till `Infinity` (eller `0`) för att ange ett obegränsat antal lyssnare. Returnerar en referens till `EventEmitter`, så att anrop kan länkas.
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)	Anger den återförsöksprincip som används av klienten för alla åtgärder. Standardvärdet är ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string \| symbol, AnyRest)

Information om ärvda egenskaper

captureRejections

Värde: booleska

Ändra standardalternativet captureRejections för alla nya EventEmitter objekt.

static captureRejections: boolean

Egenskapsvärde

boolean

ärvd från InternalClient.captureRejections

captureRejectionSymbol

Värde: Symbol.for('nodejs.rejection')

Se hur du skriver en anpassad rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Egenskapsvärde

typeof captureRejectionSymbol

ärvd från InternalClient.captureRejectionSymbol

defaultMaxListeners

Som standard kan maximalt 10 lyssnare registreras för en enskild händelse. Den här gränsen kan ändras för enskilda EventEmitter-instanser med hjälp av metoden emitter.setMaxListeners(n). Om du vill ändra standardvärdet för allaEventEmitter instanser kan egenskapen events.defaultMaxListeners användas. Om det här värdet inte är ett positivt tal genereras en RangeError.

Var försiktig när du anger events.defaultMaxListeners eftersom ändringen påverkar allaEventEmitter instanser, inklusive de som skapades innan ändringen gjordes. Men att anropa emitter.setMaxListeners(n) har fortfarande företräde framför events.defaultMaxListeners.

Detta är inte en hård gräns. Den EventEmitter instansen gör att fler lyssnare kan läggas till, men skickar en spårningsvarning till stderr som anger att en "möjlig EventEmitter-minnesläcka" har identifierats. För en enskild EventEmitterkan metoderna emitter.getMaxListeners() och emitter.setMaxListeners() användas för att tillfälligt undvika den här varningen:

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

Den --trace-warnings kommandoradsflaggan kan användas för att visa stackspårningen för sådana varningar.

Den avgivna varningen kan inspekteras med process.on('warning') och har ytterligare egenskaper emitter, typeoch count, med hänvisning till händelseemitterarens instans, händelsens namn respektive antalet anslutna lyssnare. Egenskapen name är inställd på 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Egenskapsvärde

number

ärvd från InternalClient.defaultMaxListeners

errorMonitor

Denna symbol ska användas för att installera en lyssnare för att endast övervaka 'error' händelser. Lyssnare som installeras med den här symbolen anropas innan de vanliga 'error' lyssnarna anropas.

När du installerar en lyssnare med den här symbolen ändras inte beteendet när en 'error' händelse har genererats. Därför kraschar processen fortfarande om ingen vanlig 'error' lyssnaren är installerad.

static errorMonitor: typeof errorMonitor

Egenskapsvärde

typeof errorMonitor

ärvd från InternalClient.errorMonitor

Metodinformation

close()

function close(): Promise<Disconnected>

Returer

Promise<Disconnected>

close(Callback<Disconnected>)

Stänger transportanslutningen och förstör klientresurserna.

Obs! När du har anropat den här metoden kan inte ModuleClient-objektet återanvändas.

function close(closeCallback?: Callback<Disconnected>)

Parametrar

closeCallback: Callback<Disconnected>

Valfri funktion att anropa när transporten är frånkopplad och klienten stängs.

fromAuthenticationProvider(AuthenticationProvider, any)

Skapar en IoT Hub-modulklient från den angivna autentiseringsmetoden och använder den angivna transporttypen.

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

Parametrar

authenticationProvider: AuthenticationProvider

Objekt som används för att hämta autentiseringsparametrarna för IoT-hubben.

transportCtor: any

Transportprotokoll som används för att ansluta till IoT Hub.

Returer

ModuleClient

fromConnectionString(string, any)

Skapar en IoT Hub-enhetsklient från den angivna anslutningssträngen med den angivna transporttypen.

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

Parametrar

connStr: string

En anslutningssträng som kapslar in "enhetsanslutningsbehörigheter" på en IoT-hubb.

transportCtor: any

En transportkonstruktor.

Returer

ModuleClient

fromEnvironment(any)

static function fromEnvironment(transportCtor: any): Promise<ModuleClient>

Parametrar

transportCtor: any

Returer

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Skapar en IoT Hub-modulklient med hjälp av konfigurationsinformation från miljön.

Om det finns en miljövariabel med namnet EdgeHubConnectionString eller IotHubConnectionString används det värdet och beteendet är identiskt med att anropa fromConnectionString skicka in det. Om dessa miljövariabler inte finns måste följande variabler definieras:

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"

static function fromEnvironment(transportCtor: any, callback?: Callback<ModuleClient>)

Parametrar

transportCtor: any

Transportprotokoll som används för att ansluta till IoT Hub.

callback: Callback<ModuleClient>

Valfritt återanrop för att anropa när ModuleClient har konstruerats eller om ett fel inträffar när klienten skapas.

fromSharedAccessSignature(string, any)

Skapar en IoT Hub-modulklient från den angivna signaturen för delad åtkomst med den angivna transporttypen.

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

Parametrar

sharedAccessSignature: string

En signatur för delad åtkomst som kapslar in behörigheter för "enhetsanslutning" på en IoT-hubb.

transportCtor: any

Returer

ModuleClient

invokeMethod(string, MethodParams)

function invokeMethod(deviceId: string, methodParams: MethodParams): Promise<MethodResult>

Parametrar

deviceId: string

methodParams: MethodParams

Returer

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Anropar en metod på en nedströmsenhet eller på en annan modul på samma IoTEdge-enhet. Observera att den här funktionen endast fungerar när modulen körs som en del av en IoTEdge-enhet.

function invokeMethod(deviceId: string, methodParams: MethodParams, callback?: Callback<MethodResult>)

Parametrar

deviceId: string

målenhetsidentifierare

methodParams: MethodParams

parametrar för direktmetodanropet

callback: Callback<MethodResult>

valfritt återanrop som anropas antingen med ett felobjekt eller resultatet av metodanropet.

invokeMethod(string, string, MethodParams)

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams): Promise<MethodResult>

Parametrar

deviceId: string

moduleId: string

methodParams: MethodParams

Returer

Promise<MethodResult>

invokeMethod(string, string, MethodParams, Callback<MethodResult>)

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams, callback: Callback<MethodResult>)

Parametrar

deviceId: string

moduleId: string

methodParams: MethodParams

callback: Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Registrerar ett återanrop för en metod med namnet methodName.

function onMethod(methodName: string, callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Parametrar

methodName: string

Namnet på den metod som ska hanteras av återanropet

callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

Funktion som ska anropas när en metodbegäran för metoden som kallas methodName tas emot.

sendOutputEvent(string, Message)

function sendOutputEvent(outputName: string, message: Message): Promise<MessageEnqueued>

Parametrar

outputName: string

message: Message

Returer

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Skickar en händelse till den angivna modulens utdata

function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)

Parametrar

outputName: string

Namnet på de utdata som händelsen ska skickas till

message: Message

Meddelande som ska skickas till angivna utdata

callback: Callback<MessageEnqueued>

Valfri funktion att anropa när åtgärden har placerats i kö.

sendOutputEventBatch(string, Message[])

function sendOutputEventBatch(outputName: string, messages: Message[]): Promise<MessageEnqueued>

Parametrar

outputName: string

messages: Message[]

Returer

Promise<MessageEnqueued>

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Skickar en matris med händelser till den angivna modulens utdata

function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)

Parametrar

outputName: string

Namnet på de utdata som händelserna ska skickas till

messages: Message[]

callback: Callback<MessageEnqueued>

Funktion för att anropa när åtgärderna har placerats i kö.

setOptions(DeviceClientOptions)

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

Parametrar

options: DeviceClientOptions

Returer

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Skickar alternativ till det ModuleClient objekt som kan användas för att konfigurera transporten.

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

Parametrar

options: DeviceClientOptions

Ett DeviceClientOptions-objekt.

done: Callback<TransportConfigured>

Valfritt återanrop för att anropa när alternativen har angetts.

Ärvd metodinformation

abandon(Message)

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

Parametrar

message: Message

Returer

Promise<MessageAbandoned>

ärvd från InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>)

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

Parametrar

message: Message

abandonCallback: Callback<MessageAbandoned>

ärvd från InternalClient.abandon

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

Lyssnar en gång på händelsen abort på den angivna signal.

Att lyssna på den abort händelsen vid avbrutna signaler är osäkert och kan leda till resursläckor eftersom en annan tredje part med signalen kan anropa e.stopImmediatePropagation(). Tyvärr kan Node.js inte ändra detta eftersom det skulle bryta mot webbstandarden. Dessutom gör det ursprungliga API:et det enkelt att glömma att ta bort lyssnare.

Med det här API:et kan du på ett säkert sätt använda AbortSignali Node.js API:er genom att lösa dessa två problem genom att lyssna på händelsen så att stopImmediatePropagation inte hindrar lyssnaren från att köras.

Returnerar en disponibel fil så att den kan avsluta prenumerationen på ett enklare sätt.

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

Parametrar

signal: AbortSignal

resource: (event: Event) => void

Returer

Disposable

Disponibel som tar bort abort lyssnaren.

ärvd från InternalClient.addAbortListener

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

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

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

Parametrar

eventName: string | symbol

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

Returer

ModuleClient

ärvd från InternalClient.addListener

complete(Message)

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

Parametrar

message: Message

Returer

Promise<MessageCompleted>

ärvd från InternalClient.complete

complete(Message, Callback<MessageCompleted>)

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

Parametrar

message: Message

completeCallback: Callback<MessageCompleted>

ärvd från InternalClient.complete

emit<K>(string | symbol, AnyRest)

Anropar synkront var och en av lyssnarna som registrerats för händelsen med namnet eventName, i den ordning de registrerades och skickar de angivna argumenten till var och en.

Returnerar true om händelsen hade lyssnare, false annars.

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

Parametrar

eventName: string | symbol

args: AnyRest

Returer

boolean

ärvd från InternalClient.emit

eventNames()

Returnerar en matris som visar de händelser som sändaren har registrerade lyssnare för. Värdena i matrisen är strängar eller 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)[]

Returer

(string | symbol)[]

ärvd från InternalClient.eventNames

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

Returnerar en kopia av matrisen med lyssnare för händelsen med namnet eventName.

För EventEmitterfungerar detta exakt som att anropa .listeners på emittern.

För EventTargetär det här det enda sättet att hämta händelselyssnare för händelsemålet. Detta är användbart för felsökning och diagnostik.

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

Parametrar

emitter: EventEmitter<DefaultEventMap> | EventTarget

name: string | symbol

Returer

Function[]

ärvd från InternalClient.getEventListeners

getMaxListeners()

Returnerar det aktuella maximala lyssnarvärdet för EventEmitter som antingen anges av emitter.setMaxListeners(n) eller som standard till defaultMaxListeners.

function getMaxListeners(): number

Returer

number

ärvd från InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Returnerar den för närvarande angivna maximala mängden lyssnare.

För EventEmitterfungerar detta exakt som att anropa .getMaxListeners på emittern.

För EventTargetär det här det enda sättet att få maximalt antal händelselyssnare för händelsemålet. Om antalet händelsehanterare på en enskild EventTarget överskrider maxuppsättningen skriver EventTarget ut en varning.

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

Parametrar

emitter: EventEmitter<DefaultEventMap> | EventTarget

Returer

number

ärvd från InternalClient.getMaxListeners

getTwin()

function getTwin(): Promise<Twin>

Returer

Promise<Twin>

ärvd från InternalClient.getTwin

getTwin(Callback<Twin>)

function getTwin(done: Callback<Twin>)

Parametrar

done: Callback<Twin>

ärvd från InternalClient.getTwin

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Varning

Det här API:et är nu inaktuellt.

Since v3.2.0 - Use listenerCount instead.

En klassmetod som returnerar antalet lyssnare för den angivna eventName som registrerats på den angivna emitter.

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

Parametrar

emitter: EventEmitter<DefaultEventMap>

Den emitter som ska frågas

eventName: string | symbol

Händelsenamnet

Returer

number

ärvd från InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

Returnerar antalet lyssnare som lyssnar efter händelsen med namnet eventName. Om listener anges returneras hur många gånger lyssnaren finns i listan över lyssnarna för händelsen.

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

Parametrar

eventName: string | symbol

Namnet på händelsen som lyssnas efter

listener: Function

Händelsehanterarfunktionen

Returer

number

ärvd från InternalClient.listenerCount

listeners<K>(string | symbol)

Returnerar en kopia av matrisen med lyssnare för händelsen med namnet 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[]

Parametrar

eventName: string | symbol

Returer

Function[]

ärvd från InternalClient.listeners

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

Alias för emitter.removeListener().

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

Parametrar

eventName: string | symbol

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

Returer

ModuleClient

ärvd från 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

Returnerar en AsyncIterator som itererar eventName händelser. Det utlöser om EventEmitter genererar 'error'. Den tar bort alla lyssnare när du avslutar loopen. Den value som returneras av varje iteration är en matris som består av de utgivna händelseargumenten.

En AbortSignal kan användas för att avbryta väntan på händelser:

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

Använd alternativet close för att ange en matris med händelsenamn som avslutar iterationen:

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>

Parametrar

emitter: EventEmitter<DefaultEventMap>

eventName: string | symbol

options: StaticEventEmitterIteratorOptions

Returer

AsyncIterator<any[], any, any>

En AsyncIterator som itererar eventName händelser som genereras av emitter

ärvd från InternalClient.on

on(EventTarget, string, StaticEventEmitterIteratorOptions)

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

Parametrar

emitter: EventTarget

eventName: string

options: StaticEventEmitterIteratorOptions

Returer

AsyncIterator<any[], any, any>

ärvd från InternalClient.on

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

Lägger till funktionen listener i slutet av lyssnarmatrisen för händelsen med namnet eventName. Inga kontroller görs för att se om listener redan har lagts till. Flera anrop som skickar samma kombination av eventName och listener resulterar i att listener läggs till och anropas flera gånger.

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

Som standard anropas händelselyssnare i den ordning de läggs till. Metoden emitter.prependListener() kan användas som ett alternativ för att lägga till händelselyssnaren i början av lyssnarmatrisen.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Parametrar

eventName: string | symbol

Namnet på händelsen.

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

Återanropsfunktionen

Returer

ModuleClient

ärvd från InternalClient.on

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

Skapar en Promise som uppfylls när EventEmitter genererar den angivna händelsen eller som avvisas om EventEmitter genererar 'error' i väntan. Den Promise löser med en matris med alla argument som genereras till den angivna händelsen.

Den här metoden är avsiktligt generisk och fungerar med webbplattformen EventTarget-gränssnittet, som inte har någon särskild'error' händelsesemantik och inte lyssnar på 'error' händelsen.

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

Den särskilda hanteringen av händelsen 'error' används bara när events.once() används för att vänta på en annan händelse. Om events.once() används för att vänta på själva händelsen "error' behandlas den som någon annan typ av händelse utan särskild hantering:

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

En AbortSignal kan användas för att avbryta väntan på händelsen:

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

Parametrar

emitter: EventEmitter<DefaultEventMap>

eventName: string | symbol

options: StaticEventEmitterOptions

Returer

Promise<any[]>

ärvd från InternalClient.once

once(EventTarget, string, StaticEventEmitterOptions)

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

Parametrar

emitter: EventTarget

eventName: string

options: StaticEventEmitterOptions

Returer

Promise<any[]>

ärvd från InternalClient.once

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

Lägger till en engångsfunktion förlistener för händelsen med namnet eventName. Nästa gång eventName utlöses tas lyssnaren bort och anropas sedan.

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

Som standard anropas händelselyssnare i den ordning de läggs till. Metoden emitter.prependOnceListener() kan användas som ett alternativ för att lägga till händelselyssnaren i början av lyssnarmatrisen.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Parametrar

eventName: string | symbol

Namnet på händelsen.

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

Återanropsfunktionen

Returer

ModuleClient

ärvd från InternalClient.once

open()

function open(): Promise<Connected>

Returer

Promise<Connected>

ärvd från InternalClient.open

open(Callback<Connected>)

function open(openCallback: Callback<Connected>)

Parametrar

openCallback: Callback<Connected>

ärvd från InternalClient.open

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

Lägger till funktionen listener i början av lyssnarmatrisen för händelsen med namnet eventName. Inga kontroller görs för att se om listener redan har lagts till. Flera anrop som skickar samma kombination av eventName och listener resulterar i att listener läggs till och anropas flera gånger.

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

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

Parametrar

eventName: string | symbol

Namnet på händelsen.

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

Återanropsfunktionen

Returer

ModuleClient

ärvd från InternalClient.prependListener

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

Lägger till en engångsfunktion förlistener för händelsen med namnet eventName till början av lyssnarmatrisen. Nästa gång eventName utlöses tas lyssnaren bort och anropas sedan.

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

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

Parametrar

eventName: string | symbol

Namnet på händelsen.

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

Återanropsfunktionen

Returer

ModuleClient

ärvd från InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Returnerar en kopia av matrisen med lyssnare för händelsen med namnet eventName, inklusive eventuella omslutningar (till exempel de som skapats av .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[]

Parametrar

eventName: string | symbol

Returer

Function[]

ärvd från InternalClient.rawListeners

reject(Message)

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

Parametrar

message: Message

Returer

Promise<MessageRejected>

ärvd från InternalClient.reject

reject(Message, Callback<MessageRejected>)

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

Parametrar

message: Message

rejectCallback: Callback<MessageRejected>

ärvd från InternalClient.reject

removeAllListeners(string | symbol)

Tar bort alla lyssnare eller de som anges eventName.

Det är dålig praxis att ta bort lyssnare som lagts till någon annanstans i koden, särskilt när den EventEmitter instansen skapades av någon annan komponent eller modul (t.ex. sockets eller filströmmar).

Returnerar en referens till EventEmitter, så att anrop kan länkas.

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

Parametrar

eventName: string | symbol

Returer

ModuleClient

ärvd från InternalClient.removeAllListeners

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

Tar bort den angivna listener från lyssnarmatrisen för händelsen med namnet eventName.

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

removeListener() tar högst bort en instans av en lyssnare från lyssnarmatrisen. Om en enskild lyssnare har lagts till flera gånger i lyssnarmatrisen för den angivna eventNamemåste removeListener() anropas flera gånger för att ta bort varje instans.

När en händelse har genererats anropas alla lyssnare som är anslutna till den vid tidpunkten för avsändande i ordning. Detta innebär att alla removeListener()- eller removeAllListeners()-anrop efter avger och innan den senaste lyssnaren slutför körningen inte tar bort dem frånemit() pågår. Efterföljande händelser fungerar som förväntat.

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

Eftersom lyssnare hanteras med hjälp av en intern matris ändras positionsindexen för alla lyssnare som registrerats när lyssnaren tas bort. Detta påverkar inte i vilken ordning lyssnare anropas, men det innebär att alla kopior av lyssnarmatrisen som returneras av metoden emitter.listeners() måste återskapas.

När en enskild funktion har lagts till som hanterare flera gånger för en enskild händelse (som i exemplet nedan) tar removeListener() bort den senast tillagda instansen. I exemplet tas once('ping') lyssnaren bort:

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

Returnerar en referens till EventEmitter, så att anrop kan länkas.

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

Parametrar

eventName: string | symbol

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

Returer

ModuleClient

ärvd från InternalClient.removeListener

sendEvent(Message)

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

Parametrar

message: Message

Returer

Promise<MessageEnqueued>

ärvd från InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>)

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

Parametrar

message: Message

sendEventCallback: Callback<MessageEnqueued>

ärvd från InternalClient.sendEvent

sendEventBatch(Message[])

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

Parametrar

messages: Message[]

Returer

Promise<MessageEnqueued>

ärvd från InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>)

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

Parametrar

messages: Message[]

sendEventBatchCallback: Callback<MessageEnqueued>

ärvd från InternalClient.sendEventBatch

setMaxListeners(number)

Som standard skriver EventEmitterut en varning om fler än 10 lyssnare läggs till för en viss händelse. Det här är ett användbart standardvärde som hjälper dig att hitta minnesläckor. Med metoden emitter.setMaxListeners() kan gränsen ändras för den här specifika EventEmitter instansen. Värdet kan anges till Infinity (eller 0) för att ange ett obegränsat antal lyssnare.

Returnerar en referens till EventEmitter, så att anrop kan länkas.

function setMaxListeners(n: number): ModuleClient

Parametrar

n: number

Returer

ModuleClient

ärvd från 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)[])

Parametrar

n: number

Ett icke-negativt tal. Maximalt antal lyssnare per EventTarget händelse.

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

Noll eller fler {EventTarget} eller {EventEmitter}-instanser. Om ingen anges anges n som standard max för alla nyligen skapade {EventTarget}- och {EventEmitter}-objekt.

ärvd från InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Anger den återförsöksprincip som används av klienten för alla åtgärder. Standardvärdet är ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parametrar

policy: RetryPolicy

{RetryPolicy} Den återförsöksprincip som ska användas för alla framtida åtgärder.

ärvd från InternalClient.setRetryPolicy

setTransportOptions(any)

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

Parametrar

options: any

Returer

Promise<TransportConfigured>

ärvd från InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>)

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

Parametrar

options: any

done: Callback<TransportConfigured>

ärvd från InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)

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

Parametrar

sharedAccessSignature: string

updateSasCallback: Callback<SharedAccessSignatureUpdated>

ärvd från InternalClient.updateSharedAccessSignature

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

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

Parametrar

error: Error

event: string | symbol

args: AnyRest

ärvd från InternalClient.__@captureRejectionSymbol@141

Dela via

ModuleClient class

Ärvda egenskaper

Metoder

Ärvda metoder

Information om ärvda egenskaper

captureRejections

Egenskapsvärde

captureRejectionSymbol

Egenskapsvärde

defaultMaxListeners

Egenskapsvärde

errorMonitor

Egenskapsvärde

Metodinformation

close()

Returer

close(Callback<Disconnected>)

Parametrar

fromAuthenticationProvider(AuthenticationProvider, any)

Parametrar

Returer

fromConnectionString(string, any)

Parametrar

Returer

fromEnvironment(any)

Parametrar

Returer

fromEnvironment(any, Callback<ModuleClient>)

Parametrar

fromSharedAccessSignature(string, any)

Parametrar

Returer

invokeMethod(string, MethodParams)

Parametrar

Returer

invokeMethod(string, MethodParams, Callback<MethodResult>)

Parametrar

invokeMethod(string, string, MethodParams)

Parametrar

Returer

invokeMethod(string, string, MethodParams, Callback<MethodResult>)

Parametrar

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Parametrar

sendOutputEvent(string, Message)

Parametrar

Returer

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Parametrar

sendOutputEventBatch(string, Message[])

Parametrar

Returer

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Parametrar

setOptions(DeviceClientOptions)

Parametrar

Returer

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Parametrar

Ärvd metodinformation

abandon(Message)

Parametrar

Returer

abandon(Message, Callback<MessageAbandoned>)

Parametrar

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

Parametrar

Returer

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

Parametrar

Returer

complete(Message)

Parametrar

Returer

complete(Message, Callback<MessageCompleted>)

Parametrar

emit<K>(string | symbol, AnyRest)

Parametrar

Returer