ModuleClient class

Csomag:: azure-iot-device

IoT Hub-eszközügyfél, amellyel egy eszközt csatlakoztathat egy Azure IoT Hubhoz.

Az SDK felhasználóinak meg kell hívniuk az egyik gyári metódust, aConnectionString vagy a fromSharedAccessSignature egy IoT Hub-eszközügyfél létrehozásához.

Extends: InternalClient

Metódusok

close()
close(Callback<Disconnected>)	Bezárja az átviteli kapcsolatot, és megsemmisíti az ügyfélerőforrásokat. megjegyzés: A metódus meghívása után a ModuleClient objektum nem használható újra.
fromAuthenticationProvider(AuthenticationProvider, any)	Létrehoz egy IoT Hub-modulügyfélt a megadott hitelesítési módszerből és a megadott átviteli típus használatával.
fromConnectionString(string, any)	Létrehoz egy IoT Hub-eszközügyfélt az adott kapcsolati sztringből a megadott átviteli típus használatával.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)	Létrehoz egy IoT Hub-modulügyfélt a környezet konfigurációs adatainak használatával. Ha létezik egy `EdgeHubConnectionString` vagy `IotHubConnectionString` nevű környezeti változó, akkor a rendszer ezt az értéket használja, és a viselkedés megegyezik a `fromConnectionString` átengedésével. Ha ezek a környezeti változók nem léteznek, akkor a következő változókat kell definiálni: `- 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)	Létrehoz egy IoT Hub-modulügyfélt a megadott közös hozzáférésű jogosultságkódból az adott átviteli típus használatával.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)	Metódust hív meg egy alsóbb rétegbeli eszközön vagy egy másik modulon ugyanazon az IoTEdge-eszközön. Vegye figyelembe, hogy ez a funkció csak akkor működik, ha a modul egy IoTEdge-eszköz részeként fut.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)	Egy `methodName`nevű metódus visszahívását regisztrálja.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)	Esemény küldése az adott modul kimenetére
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)	Eseménytömb küldése az adott modul kimenetére
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)	Átadja a beállításokat az átvitel konfigurálásához használható `ModuleClient` objektumnak.

Örökölt metódusok

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addListener<E>(string \| symbol, (args: any[]) => void)	Alias a következőhöz `emitter.on(eventName, listener)`: .
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<E>(string \| symbol, any[])	Szinkron módon meghívja a `eventName`nevű eseményre regisztrált összes figyelőt, a regisztráció sorrendjében, és átadja a megadott argumentumokat mindegyiknek. `true` ad vissza, ha az esemény figyelői voltak, `false` ellenkező esetben. 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()	Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket. `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) ]`
getMaxListeners()	A `EventEmitter` aktuális maximális figyelőértékét adja vissza, amelyet `emitter.setMaxListeners(n)` vagy alapértelmezés szerint `events.defaultMaxListeners`értékre állít be.
getTwin()
getTwin(Callback<Twin>)
listenerCount<E>(string \| symbol, (args: any[]) => void)	A `eventName`nevű eseményt figyelő figyelők számát adja vissza. Ha `listener` van megadva, az visszaadja, hogy hányszor található a figyelő az esemény figyelőinek listájában.
listeners<E>(string \| symbol)	A `eventName`nevű esemény figyelőinek tömbjének másolatát adja vissza. `server.on('connection', (stream) => { console.log('someone connected!'); }); console.log(util.inspect(server.listeners('connection'))); // Prints: [ [Function] ]`
off<E>(string \| symbol, (args: any[]) => void)	Alias a következőhöz `emitter.removeListener()`: .
on<E>(string \| symbol, (args: any[]) => void)	Hozzáadja a `listener` függvényt a `eventName`nevű esemény figyelőtömbjének végéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a `listener` már hozzáadták-e. A `eventName` és a `listener` azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a `listener`. `server.on('connection', (stream) => { console.log('someone connected!'); });` A `EventEmitter`mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek. Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A `emitter.prependListener()` metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez. `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<E>(string \| symbol, (args: any[]) => void)	Hozzáad egy egyszeri`listener` függvényt a `eventName`nevű eseményhez. A következő `eventName` aktiválásakor a figyelő el lesz távolítva, majd meghívódik. `server.once('connection', (stream) => { console.log('Ah, we have our first user!'); });` A `EventEmitter`mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek. Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A `emitter.prependOnceListener()` metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez. `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<E>(string \| symbol, (args: any[]) => void)	Hozzáadja a függvényt a nevű esemény figyelőtömbjének . Nem történik ellenőrzés annak ellenőrzésére, hogy a `listener` már hozzáadták-e. A `eventName` és a `listener` azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a `listener`. `server.prependListener('connection', (stream) => { console.log('someone connected!'); });` A `EventEmitter`mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
prependOnceListener<E>(string \| symbol, (args: any[]) => void)	Hozzáad egy egyszeri függvényt a figyelőtömb nevű eseményhez. A következő `eventName` aktiválásakor a figyelő el lesz távolítva, majd meghívódik. `server.prependOnceListener('connection', (stream) => { console.log('Ah, we have our first user!'); });` A `EventEmitter`mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
rawListeners<E>(string \| symbol)	Visszaadja a `eventName`nevű esemény figyelőinek tömbjének másolatát, beleértve a burkolókat is (például az `.once()`által létrehozottakat). 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<E>(string \| symbol)	Eltávolítja az összes figyelőt vagy a megadott `eventName`. Helytelen gyakorlat eltávolítani a kód más részeiben hozzáadott figyelőket, különösen akkor, ha a `EventEmitter`-példányt más összetevő vagy modul hozta létre (például szoftvercsatornák vagy fájlstreamek). A `EventEmitter`mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
removeListener<E>(string \| symbol, (args: any[]) => void)	Eltávolítja a megadott `listener` a `eventName`nevű esemény figyelőtömbéből. `const callback = (stream) => { console.log('someone connected!'); }; server.on('connection', callback); // ... server.removeListener('connection', callback);` `removeListener()` legfeljebb egy figyelőpéldányt távolít el a figyelőtömbből. Ha a megadott `eventName`egyetlen figyelőt többször is hozzáadtak a figyelőtömbhöz, akkor az egyes példányok eltávolításához `removeListener()` többször kell meghívni. Ha egy eseményt bocsát ki, a rendszer sorrendben meghívja a kibocsátáskor az ahhoz csatolt összes figyelőt. Ez azt jelenti, hogy `removeListener()removeAllListeners()` a hívások a kibocsátás után, mielőtt az utolsó hallgató befejezi a végrehajtást, nem távolítják el a `emit()` folyamatból. A későbbi események a várt módon viselkednek. 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 Mivel a hallgatókat belső tömbben kezelik, ennek meghívása megváltoztatja bármely hallgató pozícióindexét , amelyet a hallgató eltávolítása után regisztrálnak. Ez nem befolyásolja a figyelők meghívásának sorrendjét, de ez azt jelenti, hogy a figyelőtömbnek az `emitter.listeners()` metódus által visszaadott másolatait újra létre kell hozni. Ha egyetlen függvényt többször adtak hozzá kezelőként egyetlen eseményhez (az alábbi példához hasonlóan), `removeListener()` eltávolítja a legutóbb hozzáadott példányt. A példában a `once('ping')` figyelő el lesz távolítva: `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');` A `EventEmitter`mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)	Alapértelmezés szerint `EventEmitter`s figyelmeztetést jelenít meg, ha egy adott eseményhez több mint `10` figyelő van hozzáadva. Ez egy hasznos alapértelmezett beállítás, amely segít megtalálni a memóriavesztést. A `emitter.setMaxListeners()` metódus lehetővé teszi a korlát módosítását ehhez az adott `EventEmitter` példányhoz. Az érték beállítható `Infinity` (vagy `0`) értékre, hogy korlátlan számú figyelőt jelöljön. A `EventEmitter`mutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
setRetryPolicy(RetryPolicy)	Beállítja az ügyfél által az összes művelethez használt újrapróbálkozási szabályzatot. Az alapértelmezett érték ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol](Error, string \| symbol, any[])	A `Symbol.for('nodejs.rejection')` módszert akkor hívják el, ha ígéretelutasítás történik esemény kibocsátásakor, és `captureRejections` az emitterben engedélyezett. Lehetséges a `events.captureRejectionSymbolSymbol.for('nodejs.rejection')`helyett használni. `import { EventEmitter, captureRejectionSymbol } from 'node:events'; class MyClass extends EventEmitter { constructor() { super({ captureRejections: true }); } [captureRejectionSymbol](err, event, ...args) { console.log('rejection happened for', event, 'with', err, ...args); this.destroy(err); } destroy(err) { // Tear the resource down here. } }`

Metódus adatai

close()

function close(): Promise<Disconnected>

Válaszok

Promise<Disconnected>

close(Callback<Disconnected>)

Bezárja az átviteli kapcsolatot, és megsemmisíti az ügyfélerőforrásokat.

megjegyzés: A metódus meghívása után a ModuleClient objektum nem használható újra.

function close(closeCallback?: Callback<Disconnected>)

Paraméterek

closeCallback: Callback<Disconnected>

Nem kötelező függvény, amely az átvitel leválasztása és az ügyfél bezárása után hívható meg.

fromAuthenticationProvider(AuthenticationProvider, any)

Létrehoz egy IoT Hub-modulügyfélt a megadott hitelesítési módszerből és a megadott átviteli típus használatával.

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

Paraméterek

authenticationProvider: AuthenticationProvider

Az IoT Hub hitelesítési paramétereinek lekéréséhez használt objektum.

transportCtor: any

Az IoT Hubhoz való csatlakozáshoz használt átviteli protokoll.

Válaszok

ModuleClient

fromConnectionString(string, any)

Létrehoz egy IoT Hub-eszközügyfélt az adott kapcsolati sztringből a megadott átviteli típus használatával.

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

Paraméterek

connStr: string

Egy kapcsolati sztring, amely az "eszközcsatlakozás" engedélyeket foglalja magában egy IoT Hubon.

transportCtor: any

Egy szállítókonstruktor.

Válaszok

ModuleClient

fromEnvironment(any)

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

Paraméterek

transportCtor: any

Válaszok

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Létrehoz egy IoT Hub-modulügyfélt a környezet konfigurációs adatainak használatával.

Ha létezik egy EdgeHubConnectionString vagy IotHubConnectionString nevű környezeti változó, akkor a rendszer ezt az értéket használja, és a viselkedés megegyezik a fromConnectionString átengedésével. Ha ezek a környezeti változók nem léteznek, akkor a következő változókat kell definiálni:

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

Paraméterek

transportCtor: any

Az IoT Hubhoz való csatlakozáshoz használt átviteli protokoll.

callback: Callback<ModuleClient>

Nem kötelező visszahívás a ModuleClient létrehozásakor vagy hiba esetén az ügyfél létrehozásakor.

fromSharedAccessSignature(string, any)

Létrehoz egy IoT Hub-modulügyfélt a megadott közös hozzáférésű jogosultságkódból az adott átviteli típus használatával.

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

Paraméterek

sharedAccessSignature: string

Egy közös hozzáférésű jogosultságkód, amely az "eszközcsatlakozás" engedélyeket foglalja magában egy IoT Hubon.

transportCtor: any

Válaszok

ModuleClient

invokeMethod(string, MethodParams)

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

Paraméterek

deviceId: string

methodParams: MethodParams

Válaszok

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Metódust hív meg egy alsóbb rétegbeli eszközön vagy egy másik modulon ugyanazon az IoTEdge-eszközön. Vegye figyelembe, hogy ez a funkció csak akkor működik, ha a modul egy IoTEdge-eszköz részeként fut.

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

Paraméterek

deviceId: string

céleszköz azonosítója

methodParams: MethodParams

a közvetlen metódushívás paraméterei

callback: Callback<MethodResult>

nem kötelező visszahívás, amely hibaobjektummal vagy a metódushívás eredményével lesz meghívva.

invokeMethod(string, string, MethodParams)

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

Paraméterek

deviceId: string

moduleId: string

methodParams: MethodParams

Válaszok

Promise<MethodResult>

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

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

Paraméterek

deviceId: string

moduleId: string

methodParams: MethodParams

callback: Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Egy methodNamenevű metódus visszahívását regisztrálja.

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

Paraméterek

methodName: string

A visszahívás által kezelni kívánt metódus neve

callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

A methodName nevű metódusra vonatkozó metóduskérések fogadásakor meghívandó függvény.

sendOutputEvent(string, Message)

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

Paraméterek

outputName: string

message: Message

Válaszok

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Esemény küldése az adott modul kimenetére

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

Paraméterek

outputName: string

Annak a kimenetnek a neve, amelybe az eseményt el szeretné küldeni

message: Message

A megadott kimenetre küldendő üzenet

callback: Callback<MessageEnqueued>

Nem kötelező függvény, amely meghívható a művelet várólistára helyezésekor.

sendOutputEventBatch(string, Message[])

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

Paraméterek

outputName: string

messages: Message[]

Válaszok

Promise<MessageEnqueued>

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

Eseménytömb küldése az adott modul kimenetére

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

Paraméterek

outputName: string

Annak a kimenetnek a neve, amelybe az eseményeket el szeretné küldeni

messages: Message[]

callback: Callback<MessageEnqueued>

A műveletek várólistára helyezésekor hívható függvény.

setOptions(DeviceClientOptions)

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

Paraméterek

options: DeviceClientOptions

Válaszok

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Átadja a beállításokat az átvitel konfigurálásához használható ModuleClient objektumnak.

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

Paraméterek

options: DeviceClientOptions

DeviceClientOptions objektum.

done: Callback<TransportConfigured>

Nem kötelező visszahívás a beállítások megadása után a híváshoz.

Örökölt metódus részletei

abandon(Message)

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

Paraméterek

message: Message

Válaszok

Promise<MessageAbandoned>

InternalClient.abandon örökölte

abandon(Message, Callback<MessageAbandoned>)

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

Paraméterek

message: Message

abandonCallback: Callback<MessageAbandoned>

InternalClient.abandon örökölte

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

Alias a következőhöz emitter.on(eventName, listener): .

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

Paraméterek

eventName: string | symbol

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

Válaszok

ModuleClient

InternalClient.addListener örökölte

complete(Message)

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

Paraméterek

message: Message

Válaszok

Promise<MessageCompleted>

InternalClient.complete örökölte

complete(Message, Callback<MessageCompleted>)

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

Paraméterek

message: Message

completeCallback: Callback<MessageCompleted>

InternalClient.complete örökölte

emit<E>(string | symbol, any[])

Szinkron módon meghívja a eventNamenevű eseményre regisztrált összes figyelőt, a regisztráció sorrendjében, és átadja a megadott argumentumokat mindegyiknek.

true ad vissza, ha az esemény figyelői voltak, false ellenkező esetben.

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<E>(eventName: string | symbol, args: any[]): boolean

Paraméterek

eventName: string | symbol

args: any[]

Válaszok

boolean

InternalClient.emit örökölte

eventNames()

Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket.

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

Válaszok

(string | symbol)[]

InternalClient.eventNames örökölte

getMaxListeners()

A EventEmitter aktuális maximális figyelőértékét adja vissza, amelyet emitter.setMaxListeners(n) vagy alapértelmezés szerint events.defaultMaxListenersértékre állít be.

function getMaxListeners(): number

Válaszok

number

InternalClient.getMaxListeners örökölte

getTwin()

function getTwin(): Promise<Twin>

Válaszok

Promise<Twin>

InternalClient.getTwin örökölte

getTwin(Callback<Twin>)

function getTwin(done: Callback<Twin>)

Paraméterek

done: Callback<Twin>

InternalClient.getTwin örökölte

listenerCount<E>(string | symbol, (args: any[]) => void)

A eventNamenevű eseményt figyelő figyelők számát adja vissza. Ha listener van megadva, az visszaadja, hogy hányszor található a figyelő az esemény figyelőinek listájában.

function listenerCount<E>(eventName: string | symbol, listener?: (args: any[]) => void): number

Paraméterek

eventName: string | symbol

A figyelt esemény neve

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

Az eseménykezelő függvény

Válaszok

number

InternalClient.listenerCount örökölte

listeners<E>(string | symbol)

A eventNamenevű esemény figyelőinek tömbjének másolatát adja vissza.

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

function listeners<E>(eventName: string | symbol): (args: any[]) => void[]

Paraméterek

eventName: string | symbol

Válaszok

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

InternalClient.listeners örökölte

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

Alias a következőhöz emitter.removeListener(): .

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

Paraméterek

eventName: string | symbol

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

Válaszok

ModuleClient

InternalClient.off örökölte

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

Hozzáadja a listener függvényt a eventNamenevű esemény figyelőtömbjének végéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Paraméterek

eventName: string | symbol

Az esemény neve.

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

A visszahívási függvény

Válaszok

ModuleClient

InternalClient.on örökölte

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

Hozzáad egy egyszerilistener függvényt a eventNamenevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependOnceListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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<E>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient

Paraméterek

eventName: string | symbol

Az esemény neve.

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

A visszahívási függvény

Válaszok

ModuleClient

InternalClient.once örökölte

open()

function open(): Promise<Connected>

Válaszok

Promise<Connected>

InternalClient.open örökölte

open(Callback<Connected>)

function open(openCallback: Callback<Connected>)

Paraméterek

openCallback: Callback<Connected>

InternalClient.open örökölte

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

Hozzáadja a függvényt a nevű esemény figyelőtömbjének . Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

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

Paraméterek

eventName: string | symbol

Az esemény neve.

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

A visszahívási függvény

Válaszok

ModuleClient

InternalClient.prependListener örökölte

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

Hozzáad egy egyszeri függvényt a figyelőtömb nevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

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

Paraméterek

eventName: string | symbol

Az esemény neve.

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

A visszahívási függvény

Válaszok

ModuleClient

InternalClient.prependOnceListener örökölte

rawListeners<E>(string | symbol)

Visszaadja a eventNamenevű esemény figyelőinek tömbjének másolatát, beleértve a burkolókat is (például az .once()által létrehozottakat).

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<E>(eventName: string | symbol): (args: any[]) => void[]

Paraméterek

eventName: string | symbol

Válaszok

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

InternalClient.rawListeners örökölte

reject(Message)

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

Paraméterek

message: Message

Válaszok

Promise<MessageRejected>

InternalClient.reject örökölte

reject(Message, Callback<MessageRejected>)

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

Paraméterek

message: Message

rejectCallback: Callback<MessageRejected>

InternalClient.reject örökölte

removeAllListeners<E>(string | symbol)

Eltávolítja az összes figyelőt vagy a megadott eventName.

Helytelen gyakorlat eltávolítani a kód más részeiben hozzáadott figyelőket, különösen akkor, ha a EventEmitter-példányt más összetevő vagy modul hozta létre (például szoftvercsatornák vagy fájlstreamek).

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

function removeAllListeners<E>(eventName?: string | symbol): ModuleClient

Paraméterek

eventName: string | symbol

Válaszok

ModuleClient

InternalClient.removeAllListeners örökölte

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

Eltávolítja a megadott listener a eventNamenevű esemény figyelőtömbéből.

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

removeListener() legfeljebb egy figyelőpéldányt távolít el a figyelőtömbből. Ha a megadott eventNameegyetlen figyelőt többször is hozzáadtak a figyelőtömbhöz, akkor az egyes példányok eltávolításához removeListener() többször kell meghívni.

Ha egy eseményt bocsát ki, a rendszer sorrendben meghívja a kibocsátáskor az ahhoz csatolt összes figyelőt. Ez azt jelenti, hogy removeListener()removeAllListeners() a hívások a kibocsátás után, mielőtt az utolsó hallgató befejezi a végrehajtást, nem távolítják el a emit() folyamatból. A későbbi események a várt módon viselkednek.

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

Mivel a hallgatókat belső tömbben kezelik, ennek meghívása megváltoztatja bármely hallgató pozícióindexét , amelyet a hallgató eltávolítása után regisztrálnak. Ez nem befolyásolja a figyelők meghívásának sorrendjét, de ez azt jelenti, hogy a figyelőtömbnek az emitter.listeners() metódus által visszaadott másolatait újra létre kell hozni.

Ha egyetlen függvényt többször adtak hozzá kezelőként egyetlen eseményhez (az alábbi példához hasonlóan), removeListener() eltávolítja a legutóbb hozzáadott példányt. A példában a once('ping') figyelő el lesz távolítva:

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

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

Paraméterek

eventName: string | symbol

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

Válaszok

ModuleClient

InternalClient.removeListener örökölte

sendEvent(Message)

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

Paraméterek

message: Message

Válaszok

Promise<MessageEnqueued>

InternalClient.sendEvent örökölte

sendEvent(Message, Callback<MessageEnqueued>)

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

Paraméterek

message: Message

sendEventCallback: Callback<MessageEnqueued>

InternalClient.sendEvent örökölte

sendEventBatch(Message[])

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

Paraméterek

messages: Message[]

Válaszok

Promise<MessageEnqueued>

InternalClient.sendEventBatch örökölte

sendEventBatch(Message[], Callback<MessageEnqueued>)

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

Paraméterek

messages: Message[]

sendEventBatchCallback: Callback<MessageEnqueued>

InternalClient.sendEventBatch örökölte

setMaxListeners(number)

Alapértelmezés szerint EventEmitters figyelmeztetést jelenít meg, ha egy adott eseményhez több mint 10 figyelő van hozzáadva. Ez egy hasznos alapértelmezett beállítás, amely segít megtalálni a memóriavesztést. A emitter.setMaxListeners() metódus lehetővé teszi a korlát módosítását ehhez az adott EventEmitter példányhoz. Az érték beállítható Infinity (vagy 0) értékre, hogy korlátlan számú figyelőt jelöljön.

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

function setMaxListeners(n: number): ModuleClient

Paraméterek

n: number

Válaszok

ModuleClient

InternalClient.setMaxListeners örökölte

setRetryPolicy(RetryPolicy)

Beállítja az ügyfél által az összes művelethez használt újrapróbálkozási szabályzatot. Az alapértelmezett érték ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Paraméterek

policy: RetryPolicy

{RetryPolicy} Az újrapróbálkozási szabályzat, amelyet minden jövőbeli művelethez használni kell.

InternalClient.setRetryPolicy örökölte

setTransportOptions(any)

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

Paraméterek

options: any

Válaszok

Promise<TransportConfigured>

InternalClient.setTransportOptions örökölte

setTransportOptions(any, Callback<TransportConfigured>)

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

Paraméterek

options: any

done: Callback<TransportConfigured>

InternalClient.setTransportOptions örökölte

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)

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

Paraméterek

sharedAccessSignature: string

updateSasCallback: Callback<SharedAccessSignatureUpdated>

InternalClient.updateSharedAccessSignature örökölte

[captureRejectionSymbol](Error, string | symbol, any[])

A Symbol.for('nodejs.rejection') módszert akkor hívják el, ha ígéretelutasítás történik esemény kibocsátásakor, és captureRejections az emitterben engedélyezett. Lehetséges a events.captureRejectionSymbolSymbol.for('nodejs.rejection')helyett használni.

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

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

Paraméterek

error: Error

event: string | symbol

args: any[]

Örökölt InternalClient.__@captureRejectionSymbol@127

Megosztás a következőn keresztül:

ModuleClient class

Metódusok

Örökölt metódusok

Metódus adatai

close()

Válaszok

close(Callback<Disconnected>)

Paraméterek

fromAuthenticationProvider(AuthenticationProvider, any)

Paraméterek

Válaszok

fromConnectionString(string, any)

Paraméterek

Válaszok

fromEnvironment(any)

Paraméterek

Válaszok

fromEnvironment(any, Callback<ModuleClient>)

Paraméterek

fromSharedAccessSignature(string, any)

Paraméterek

Válaszok

invokeMethod(string, MethodParams)

Paraméterek

Válaszok

invokeMethod(string, MethodParams, Callback<MethodResult>)

Paraméterek

invokeMethod(string, string, MethodParams)

Paraméterek

Válaszok

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

Paraméterek

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Paraméterek

sendOutputEvent(string, Message)

Paraméterek

Válaszok

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Paraméterek

sendOutputEventBatch(string, Message[])

Paraméterek

Válaszok

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

Paraméterek

setOptions(DeviceClientOptions)

Paraméterek

Válaszok

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Paraméterek

Örökölt metódus részletei

abandon(Message)

Paraméterek

Válaszok

abandon(Message, Callback<MessageAbandoned>)

Paraméterek

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

Paraméterek

Válaszok

complete(Message)

Paraméterek

Válaszok

complete(Message, Callback<MessageCompleted>)

Paraméterek

emit<E>(string | symbol, any[])

Paraméterek

Válaszok

eventNames()

Válaszok

getMaxListeners()

Válaszok

getTwin()

Válaszok

getTwin(Callback<Twin>)

Paraméterek

listenerCount<E>(string | symbol, (args: any[]) => void)

Paraméterek

Válaszok

listeners<E>(string | symbol)

Paraméterek