ModuleClient class

Referens

Paket:: azure-iot-device

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

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

Extends: InternalClient

Ärvda egenskaper

captureRejections	Värde: booleskt värde Ä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 antal `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 `emitter.setMaxListeners(n)` metoden . 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 ett `RangeError` . Var försiktig när du anger `events.defaultMaxListeners` eftersom ändringen påverkar alla`EventEmitter` instanser, inklusive de som skapades innan ändringen görs. Anrop `emitter.setMaxListeners(n)` har dock fortfarande företräde framför `events.defaultMaxListeners`. Detta är inte en hård gräns. Instansen `EventEmitter` gör det möjligt att lägga till fler lyssnare, men skickar en spårningsvarning till stderr som anger att en "möjlig EventEmitter-minnesläcka" har identifierats. För en enskild `EventEmitter`kan `emitter.getMaxListeners()` metoderna 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)); });` Kommandoradsflaggan `--trace-warnings` kan användas för att visa stackspårningen för sådana varningar. Den utelämnade varningen kan inspekteras med `process.on('warning')` och har `emitter`egenskaperna , `type`och `count` med hänvisning till händelseemitterarens instans, händelsens namn respektive antalet anslutna lyssnare. Dess `name` egenskap är inställd på `'MaxListenersExceededWarning'`.
errorMonitor	Denna symbol ska användas för att installera en lyssnare endast för övervakningshändelser `'error'` . Lyssnare som har installerats 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 genereras. Därför kraschar processen fortfarande om ingen vanlig `'error'` lyssnare har installerats.

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 en miljövariabel anropas `EdgeHubConnectionString` eller `IotHubConnectionString` finns används det värdet och beteendet är identiskt med anropet `fromConnectionString` som skickar 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 bara 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 objektet `ModuleClient` 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å `abort` händelsen på den angivna `signal`. Att lyssna `abort` på 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`s i Node.js-API:er genom att lösa dessa två problem genom att lyssna på händelsen som inte hindrar lyssnaren från att `stopImmediatePropagation` köras. Returnerar en disponibel fil så att den enklare kan avbryta prenumerationen. `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`s fungerar detta exakt på samma sätt som anrop `.listeners` på sändaren. För `EventTarget`s är detta 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 maxlyssningsvärdet för `EventEmitter` som antingen anges av `emitter.setMaxListeners(n)` eller standardvärdet defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> \| EventTarget)	Returnerar den för närvarande angivna maximala mängden lyssnare. För `EventEmitter`s fungerar detta exakt på samma sätt som anrop `.getMaxListeners` på sändaren. För `EventTarget`s är detta 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 angiven `eventName` registrerad på angiven `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 lyssnare av 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, StaticEventEmitterOptions)	`import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo')) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable here` Returnerar ett `AsyncIterator` som itererar `eventName` händelser. Det utlöser om `EventEmitter` genererar `'error'`. Den tar bort alla lyssnare när loopen avslutas. 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());
on(EventTarget, string, StaticEventEmitterOptions)
on<K>(string \| symbol, (args: any[]) => void)	Lägger till funktionen i `listener` 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 `listener` att 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, Pick<StaticEventEmitterOptions, "signal">)	Skapar en `Promise` som uppfylls när `EventEmitter` genererar den angivna händelsen eller som avvisas `'error'` om avger `EventEmitter` i väntan. `Promise` kommer att matcha 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 `'error'` på 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 `'error'` händelsen 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`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 i `listener`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 `listener` att 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`listener` för händelsen med namnet `eventName` i 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`i . Det är dålig praxis att ta bort lyssnare som lagts till någon annanstans i koden, särskilt när instansen `EventEmitter` 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 angivet `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 du `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 avgivandet i ordning. Detta innebär att alla `removeListener()` eller `removeAllListeners()` anrop efter avsändande och innan den senaste lyssnaren har slutfört körningen inte tar bort dem från`emit()` pågående. 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 har registrerats efter att lyssnaren har tagits bort. Detta påverkar inte i vilken ordning lyssnarna anropas, men det innebär att alla kopior av lyssnarmatrisen `emitter.listeners()` som returneras av metoden 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) `removeListener()` tas den senast tillagda instansen bort. I exemplet tas lyssnaren `once('ping')` 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 `EventEmitter`skriver s ut en varning om fler än `10` lyssnare läggs till för en viss händelse. Det här är en användbar standard som hjälper dig att hitta minnesläckor. Med metoden kan gränsen ändras för den här specifika `EventEmitter` instansen`emitter.setMaxListeners()`. 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 återförsöksprincipen 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: booleskt värde

Ä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 antal 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 emitter.setMaxListeners(n) metoden . 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 ett RangeError .

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

Detta är inte en hård gräns. Instansen EventEmitter gör det möjligt att lägga till fler lyssnare, men skickar en spårningsvarning till stderr som anger att en "möjlig EventEmitter-minnesläcka" har identifierats. För en enskild EventEmitterkan emitter.getMaxListeners() metoderna 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));
});

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

Den utelämnade varningen kan inspekteras med process.on('warning') och har emitteregenskaperna , typeoch count med hänvisning till händelseemitterarens instans, händelsens namn respektive antalet anslutna lyssnare. Dess name egenskap ä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 endast för övervakningshändelser 'error' . Lyssnare som har installerats 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 genereras. Därför kraschar processen fortfarande om ingen vanlig 'error' lyssnare har installerats.

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 en miljövariabel anropas EdgeHubConnectionString eller IotHubConnectionString finns används det värdet och beteendet är identiskt med anropet fromConnectionString som skickar 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 bara 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>

valfri motringning 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 anropas 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 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 objektet ModuleClient 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å abort händelsen på den angivna signal.

Att lyssna abort på 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 AbortSignals i Node.js-API:er genom att lösa dessa två problem genom att lyssna på händelsen som inte hindrar lyssnaren från att stopImmediatePropagation köras.

Returnerar en disponibel fil så att den enklare kan avbryta prenumerationen.

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 lyssnaren abort .

Ä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 EventEmitters fungerar detta exakt på samma sätt som anrop .listeners på sändaren.

För EventTargets är detta 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 maxlyssningsvärdet för EventEmitter som antingen anges av emitter.setMaxListeners(n) eller standardvärdet 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 EventEmitters fungerar detta exakt på samma sätt som anrop .getMaxListeners på sändaren.

För EventTargets är detta 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 angiven eventName registrerad på angiven 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 sändare 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 lyssnare av 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, StaticEventEmitterOptions)

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

const ee = new EventEmitter();

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

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

Returnerar ett AsyncIterator som itererar eventName händelser. Det utlöser om EventEmitter genererar 'error'. Den tar bort alla lyssnare när loopen avslutas. 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());

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>

Parametrar

emitter: EventEmitter<DefaultEventMap>

eventName: string | symbol

Namnet på händelsen som lyssnas efter

options: StaticEventEmitterOptions

Returer

AsyncIterableIterator<any>

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

Ärvd från InternalClient.on

on(EventTarget, string, StaticEventEmitterOptions)

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>

Parametrar

emitter: EventTarget

eventName: string

options: StaticEventEmitterOptions

Returer

AsyncIterableIterator<any>

Ärvd från InternalClient.on

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

Lägger till funktionen i listener 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 listener att 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, Pick<StaticEventEmitterOptions, "signal">)

Skapar en Promise som uppfylls när EventEmitter genererar den angivna händelsen eller som avvisas 'error' om avger EventEmitter i väntan. Promise kommer att matcha 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 'error' på 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 'error' händelsen 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ändelsenerror' 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?: Pick<StaticEventEmitterOptions, "signal">): Promise<any[]>

Parametrar

emitter: EventEmitter<DefaultEventMap>

eventName: string | symbol

options: Pick<StaticEventEmitterOptions, "signal">

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ångsfunktionlistener 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 i listenerbö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 listener att 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ångsfunktionlistener för händelsen med namnet eventName i 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 eventNamei .

Det är dålig praxis att ta bort lyssnare som lagts till någon annanstans i koden, särskilt när instansen EventEmitter 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 angivet 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 du 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 avgivandet i ordning. Detta innebär att alla removeListener() eller removeAllListeners() anrop efter avsändande och innan den senaste lyssnaren har slutfört körningen inte tar bort dem frånemit() pågående. 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 har registrerats efter att lyssnaren har tagits bort. Detta påverkar inte i vilken ordning lyssnarna anropas, men det innebär att alla kopior av lyssnarmatrisen emitter.listeners() som returneras av metoden 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) removeListener() tas den senast tillagda instansen bort. I exemplet tas lyssnaren once('ping') 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 EventEmitterskriver s ut en varning om fler än 10 lyssnare läggs till för en viss händelse. Det här är en användbar standard som hjälper dig att hitta minnesläckor. Med metoden kan gränsen ändras för den här specifika EventEmitter instansenemitter.setMaxListeners(). 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. Det maximala antalet lyssnare per EventTarget händelse.

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

Ärvd från InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

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

function setRetryPolicy(policy: RetryPolicy)

Parametrar

policy: RetryPolicy

{RetryPolicy} Återförsöksprincipen 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@145

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