ModuleClient class
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 vagya FromSharedAccessSignature metódusból egy IoT Hub-eszközügyfél létrehozásához.
- Extends
-
InternalClient
Örökölt tulajdonságok
capture |
Érték: logikai Módosítsa az alapértelmezett |
capture |
Érték: Tekintse meg, hogyan írhat egyéni |
default |
Alapértelmezés szerint legfeljebb A beállításánál Ez nem egy kemény korlát. A
A A kibocsátott figyelmeztetést megvizsgálhatja a következővel |
error |
Ezt a szimbólumot csak figyelési Ha ezzel a szimbólummal telepít egy figyelőt, az nem változtatja meg a viselkedést az |
Metódusok
close() | |
close(Callback<Disconnected>) | Bezárja az átviteli kapcsolatot, és megsemmisíti az ügyfél erőforrásait. Megjegyzés: A metódus meghívása után a ModuleClient objektum nem használható újra. |
from |
Létrehoz egy IoT Hub-modulügyfelet a megadott hitelesítési módszerből és a megadott átviteli típus használatával. |
from |
Létrehoz egy IoT Hub-eszközügyfélt a megadott kapcsolati sztringből a megadott átviteli típus használatával. |
from |
|
from |
Létrehoz egy IoT Hub-modulügyfelet a környezet konfigurációs információinak használatával. Ha egy nevű
|
from |
Létrehoz egy IoT Hub-modulügyfélt a megadott közös hozzáférésű jogosultságkódból a megadott átviteli típus használatával. |
invoke |
|
invoke |
Metódust hív meg egy lefelé irányuló 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. |
invoke |
|
invoke |
|
on |
Egy nevű metódus |
send |
|
send |
Eseményt küld a megadott modulkimenetnek |
send |
|
send |
Eseménytömböt küld az adott modul kimenetének |
set |
|
set |
Az átvitel konfigurálásához használható beállításokat |
Örökölt metódusok
abandon(Message) | |
abandon(Message, Callback<Message |
|
add |
Egyszer hallgatja meg az eseményt
Ez az API lehetővé teszi az s biztonságos használatát Eldobható értéket ad vissza, hogy könnyebben leiratkozhassunk róla.
|
add |
Alias a következőhöz: |
complete(Message) | |
complete(Message, Callback<Message |
|
emit<K>(string | symbol, Any |
Szinkron módon meghívja a nevű Akkor ad
|
event |
Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez a kibocsátó regisztrált figyelőket tartalmaz. A tömb értékei sztringek vagy
|
get |
A nevű esemény Az Az s esetében
|
get |
Az aktuális maximális figyelőértéket adja vissza, |
get |
A jelenleg beállított maximális figyelőmennyiséget adja vissza. Az Az s esetében
|
get |
|
get |
|
listener |
Osztálymetódus, amely a megadott
|
listener |
A nevű eseményt |
listeners<K>(string | symbol) | A nevű esemény
|
off<K>(string | symbol, (args: any[]) => void) | Alias a következőhöz: |
on(Event |
Olyan értéket Az eseményekre
|
on(Event |
|
on<K>(string | symbol, (args: any[]) => void) | Hozzáadja a
A parancsra mutató hivatkozást ad vissza, hogy a Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A
|
once(Event |
Olyan eseményt Ez a módszer szándékosan általános, és az EventTarget webes platform felületével működik, amely nem rendelkezik speciális
Az esemény speciális kezelését
Az
|
once(Event |
|
once<K>(string | symbol, (args: any[]) => void) | Hozzáad egy egyszeri
A parancsra mutató hivatkozást ad vissza, hogy a Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A
|
open() | |
open(Callback<Connected>) | |
prepend |
Hozzáadja a
A parancsra mutató hivatkozást ad vissza, hogy a |
prepend |
Hozzáad egy egyszeri
A parancsra mutató hivatkozást ad vissza, hogy a |
raw |
A nevű esemény
|
reject(Message) | |
reject(Message, Callback<Message |
|
remove |
Eltávolítja az összes figyelőt vagy a megadott Helytelen gyakorlat eltávolítani a kód más részeiben hozzáadott figyelőket, különösen akkor, ha a A parancsra mutató hivatkozást ad vissza, hogy a |
remove |
Eltávolítja a megadott
Az esemény kibocsátása után a rendszer a kibocsátáskor hozzá kapcsolt összes figyelőt sorrendben hívja meg. Ez azt jelenti, hogy a
Mivel a figyelők kezelése belső tömb használatával történik, a hívás megváltoztatja a figyelő eltávolítása után regisztrált figyelők pozícióindexeit. Ez nem befolyásolja a figyelők meghívásának sorrendjét, de ez azt jelenti, hogy a Ha egyetlen függvényt többször adtak hozzá kezelőként egyetlen eseményhez (az alábbi példához hasonlóan),
A parancsra mutató hivatkozást ad vissza, hogy a |
send |
|
send |
|
send |
|
send |
|
set |
Alapértelmezés szerint A parancsra mutató hivatkozást ad vissza, hogy a |
set |
|
set |
Beállítja az ügyfél által az összes művelethez használt újrapróbálkozási szabályzatot. Az alapértelmezett érték az ExponentialBackoffWithJitter. |
set |
|
set |
|
update |
|
[capture |
Örökölt tulajdonság részletei
captureRejections
Érték: logikai
Módosítsa az alapértelmezett captureRejections
beállítást az összes új EventEmitter
objektumon.
static captureRejections: boolean
Tulajdonság értéke
boolean
Örökölt forrás InternalClient.captureRejections
captureRejectionSymbol
Érték: Symbol.for('nodejs.rejection')
Tekintse meg, hogyan írhat egyéni rejection handler
elemet.
static captureRejectionSymbol: typeof captureRejectionSymbol
Tulajdonság értéke
typeof captureRejectionSymbol
Örökölt forrás InternalClient.captureRejectionSymbol
defaultMaxListeners
Alapértelmezés szerint legfeljebb 10
figyelő regisztrálható egyetlen eseményhez. Ez a korlát a metódussal emitter.setMaxListeners(n)
módosítható az egyes EventEmitter
példányok esetében. Az összesEventEmitter
példány alapértelmezett értékének módosításához a events.defaultMaxListeners
tulajdonság használható. Ha ez az érték nem pozitív szám, akkor a RangeError
lesz dobva.
A beállításánál events.defaultMaxListeners
körültekintően járjon el, mert a módosítás az összesEventEmitter
példányra hatással van, beleértve a módosítás előtt létrehozott példányokat is. A hívás emitter.setMaxListeners(n)
azonban továbbra is elsőbbséget élvez a -tal szemben events.defaultMaxListeners
.
Ez nem egy kemény korlát. A EventEmitter
példány több figyelő hozzáadását teszi lehetővé, de nyomkövetési figyelmeztetést küld az stderrnek, amely azt jelzi, hogy a rendszer "lehetséges EventEmitter memóriavesztést" észlelt. A EventEmitter
és emitter.setMaxListeners()
a emitter.getMaxListeners()
metódusok használatával ideiglenesen elkerülheti ezt a figyelmeztetést:
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));
});
A --trace-warnings
parancssori jelzővel megjeleníthető az ilyen figyelmeztetések veremkövetése.
A kibocsátott figyelmeztetést megvizsgálhatja a következővel process.on('warning')
: , és rendelkezik a további emitter
, type
és count
tulajdonságokkal, hivatkozva az esemény-kibocsátó példányra, az esemény nevére és a csatlakoztatott figyelők számára.
A name
tulajdonsága értékre 'MaxListenersExceededWarning'
van állítva.
static defaultMaxListeners: number
Tulajdonság értéke
number
Örökölt forrás InternalClient.defaultMaxListeners
errorMonitor
Ezt a szimbólumot csak figyelési 'error'
események figyelőjének telepítéséhez kell használni. Az ezzel a szimbólummal telepített figyelők a normál 'error'
figyelők hívása előtt lesznek meghívva.
Ha ezzel a szimbólummal telepít egy figyelőt, az nem változtatja meg a viselkedést az 'error'
esemény kibocsátása után. Ezért a folyamat továbbra is összeomlik, ha nincs telepítve normál 'error'
figyelő.
static errorMonitor: typeof errorMonitor
Tulajdonság értéke
typeof errorMonitor
Örökölt forrás InternalClient.errorMonitor
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él erőforrásait.
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 az átvitel leválasztása és az ügyfél bezárása után történő hívásához.
fromAuthenticationProvider(AuthenticationProvider, any)
Létrehoz egy IoT Hub-modulügyfelet 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
fromConnectionString(string, any)
Létrehoz egy IoT Hub-eszközügyfélt a megadott 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ási" engedélyeket foglalja magában egy IoT Hubon.
- transportCtor
-
any
Egy szállítókonstruktor.
Válaszok
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ügyfelet a környezet konfigurációs információinak használatával.
Ha egy nevű EdgeHubConnectionString
vagy IotHubConnectionString
létező környezeti változó van, akkor a rendszer ezt az értéket használja, és a viselkedése megegyezik a továbbadás meghívásával fromConnectionString
. 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, amely meghívható a ModuleClient létrehozásakor, vagy ha hiba történik 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 a megadott átviteli típus használatával.
static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): ModuleClient
Paraméterek
- sharedAccessSignature
-
string
Közös hozzáférésű jogosultságkód, amely az "eszközcsatlakozás" engedélyeit foglalja magában egy IoT Hubon.
- transportCtor
-
any
Válaszok
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 lefelé irányuló 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 egy Error objektummal 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 nevű metódus methodName
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>
Függvény, amelyet akkor kell meghívni, amikor metóduskérés érkezik a hívott methodName
módszerre.
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ényt küld a megadott modulkimenetnek
function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)
Paraméterek
- outputName
-
string
Annak a kimenetnek a neve, amelybe az eseményt küldeni szeretné
- message
- Message
A megadott kimenetre küldendő üzenet
- callback
-
Callback<MessageEnqueued>
Nem kötelező függvény, amelyet meghívhat, ha a művelet várólistára lett helyezve.
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öt küld az adott modul kimenetének
function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)
Paraméterek
- outputName
-
string
Annak a kimenetnek a neve, amelybe az eseményeket küldeni szeretné
- messages
-
Message[]
- callback
-
Callback<MessageEnqueued>
Függvény, amely a műveletek várólistára helyezésekor hívható meg.
setOptions(DeviceClientOptions)
function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>
Paraméterek
- options
- DeviceClientOptions
Válaszok
Promise<TransportConfigured>
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
Az átvitel konfigurálásához használható beállításokat ModuleClient
adja át az objektumnak.
function setOptions(options: DeviceClientOptions, done?: Callback<TransportConfigured>)
Paraméterek
- options
- DeviceClientOptions
Egy DeviceClientOptions objektum.
- done
-
Callback<TransportConfigured>
Nem kötelező visszahívás a híváshoz a beállítások megadása után.
Örökölt metódus részletei
abandon(Message)
function abandon(message: Message): Promise<MessageAbandoned>
Paraméterek
- message
- Message
Válaszok
Promise<MessageAbandoned>
Örökölt forrás InternalClient.abandon
abandon(Message, Callback<MessageAbandoned>)
function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)
Paraméterek
- message
- Message
- abandonCallback
-
Callback<MessageAbandoned>
Örökölt forrás InternalClient.abandon
addAbortListener(AbortSignal, (event: Event) => void)
Egyszer hallgatja meg az eseményt abort
a megadott signal
webhelyen.
abort
Az esemény megszakítási jeleken való hallgatása nem biztonságos, és erőforrás-szivárgáshoz vezethet, mivel egy másik, a jellel rendelkező harmadik fél meghívhatja a következőte.stopImmediatePropagation()
: . Sajnos Node.js nem módosíthatja ezt, mivel ez sértené a webes szabványt. Emellett az eredeti API megkönnyíti a figyelők eltávolítását.
Ez az API lehetővé teszi az s biztonságos használatát AbortSignal
Node.js API-kban, ha ezt a két problémát úgy oldja meg, hogy meghallgatja az eseményt, ami stopImmediatePropagation
nem akadályozza meg a figyelő futását.
Eldobható értéket ad vissza, hogy könnyebben leiratkozhassunk róla.
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
Paraméterek
- signal
-
AbortSignal
- resource
-
(event: Event) => void
Válaszok
Disposable
Eldobható, amely eltávolítja a figyelőt abort
.
Örökölt forrás InternalClient.addAbortListener
addListener<K>(string | symbol, (args: any[]) => void)
Alias a következőhöz: emitter.on(eventName, listener)
.
function addListener<K>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient
Paraméterek
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Válaszok
Örökölt forrás InternalClient.addListener
complete(Message)
function complete(message: Message): Promise<MessageCompleted>
Paraméterek
- message
- Message
Válaszok
Promise<MessageCompleted>
Örökölt forrás InternalClient.complete
complete(Message, Callback<MessageCompleted>)
function complete(message: Message, completeCallback: Callback<MessageCompleted>)
Paraméterek
- message
- Message
- completeCallback
-
Callback<MessageCompleted>
Örökölt forrás InternalClient.complete
emit<K>(string | symbol, AnyRest)
Szinkron módon meghívja a nevű eventName
eseményhez regisztrált összes figyelőt a regisztráció sorrendjében, és átadja a megadott argumentumokat mindegyiknek.
Akkor ad true
vissza, ha az eseménynek voltak figyelői, 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<K>(eventName: string | symbol, args: AnyRest): boolean
Paraméterek
- eventName
-
string | symbol
- args
-
AnyRest
Válaszok
boolean
Örökölt forrás InternalClient.emit
eventNames()
Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez a kibocsátó regisztrált figyelőket tartalmaz. A tömb értékei sztringek vagy 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) ]
function eventNames(): (string | symbol)[]
Válaszok
(string | symbol)[]
Örökölt forrás InternalClient.eventNames
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)
A nevű esemény eventName
figyelőinek tömbjének másolatát adja vissza.
Az EventEmitter
s esetében ez pontosan ugyanúgy viselkedik, mint a kibocsátó hívása .listeners
.
Az s esetében EventTarget
ez az egyetlen módja annak, hogy lekérje az eseménycél eseményfigyelőit. Ez hibakeresési és diagnosztikai célokra hasznos.
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[]
Paraméterek
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
- name
-
string | symbol
Válaszok
Function[]
Örökölt forrás InternalClient.getEventListeners
getMaxListeners()
Az aktuális maximális figyelőértéket adja vissza, EventEmitter
amelynek emitter.setMaxListeners(n)
alapértelmezett vagy alapértelmezett értéke a DefaultMaxListeners.
function getMaxListeners(): number
Válaszok
number
Örökölt forrás InternalClient.getMaxListeners
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)
A jelenleg beállított maximális figyelőmennyiséget adja vissza.
Az EventEmitter
s esetében ez pontosan ugyanúgy viselkedik, mint a kibocsátó hívása .getMaxListeners
.
Az s esetében EventTarget
ez az egyetlen módja annak, hogy lekérje az eseménycélhoz tartozó maximális eseményfigyelőket. Ha egy EventTarget eseménykezelőinek száma meghaladja a maximális készletet, az EventTarget figyelmeztetést fog nyomtatni.
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
Paraméterek
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
Válaszok
number
Örökölt forrás InternalClient.getMaxListeners
getTwin()
getTwin(Callback<Twin>)
function getTwin(done: Callback<Twin>)
Paraméterek
- done
-
Callback<Twin>
Örökölt forrás InternalClient.getTwin
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)
Figyelmeztetés
Ez az API már elavult.
Since v3.2.0 - Use listenerCount
instead.
Osztálymetódus, amely a megadott eventName
regisztrált figyelők számát adja vissza az adott emitter
rendszeren.
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
Paraméterek
- emitter
-
EventEmitter<DefaultEventMap>
A lekérdezendő emitter
- eventName
-
string | symbol
Az esemény neve
Válaszok
number
Örökölt forrás InternalClient.listenerCount
listenerCount<K>(string | symbol, Function)
A nevű eseményt eventName
figyelő figyelők számát adja vissza.
Ha listener
meg van adva, visszaadja, hogy hányszor található a figyelő az esemény figyelőinek listájában.
function listenerCount<K>(eventName: string | symbol, listener?: Function): number
Paraméterek
- eventName
-
string | symbol
A figyelt esemény neve
- listener
-
Function
Az eseménykezelő függvény
Válaszok
number
Örökölt forrás InternalClient.listenerCount
listeners<K>(string | symbol)
A nevű esemény eventName
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<K>(eventName: string | symbol): Function[]
Paraméterek
- eventName
-
string | symbol
Válaszok
Function[]
Örökölt forrás InternalClient.listeners
off<K>(string | symbol, (args: any[]) => void)
Alias a következőhöz: emitter.removeListener()
.
function off<K>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient
Paraméterek
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Válaszok
Örökölt forrás 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
Olyan értéket AsyncIterator
ad vissza, amely iterálja az eventName
eseményeket. Akkor dob, ha a EventEmitter
kibocsátja 'error'
. Eltávolítja az összes figyelőt a hurokból való kilépéskor. Az value
egyes iterációk által visszaadott tömb a kibocsátott eseményargumentumokból áll.
Az eseményekre AbortSignal
való várakozás megszakításához használható:
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>
Paraméterek
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string | symbol
A figyelt esemény neve
- options
-
StaticEventEmitterOptions
Válaszok
AsyncIterableIterator<any>
Egy AsyncIterator
, amely iterálja eventName
a emitter
Örökölt forrás InternalClient.on
on(EventTarget, string, StaticEventEmitterOptions)
static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>
Paraméterek
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterOptions
Válaszok
AsyncIterableIterator<any>
Örökölt forrás InternalClient.on
on<K>(string | symbol, (args: any[]) => void)
Hozzáadja a listener
függvényt a nevű esemény eventName
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áadva van-e. Több hívás, amely ugyanazt a kombinációt eventName
adja át, és listener
ennek eredményeként a listener
rendszer többször is hozzáadja és meghívja őket.
server.on('connection', (stream) => {
console.log('someone connected!');
});
A parancsra mutató hivatkozást ad vissza, hogy a EventEmitter
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<K>(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
Örökölt forrás InternalClient.on
once(EventEmitter<DefaultEventMap>, string | symbol, Pick<StaticEventEmitterOptions, "signal">)
Olyan eseményt Promise
hoz létre, amely akkor teljesül, ha az EventEmitter
adott eseményt bocsátja ki, vagy ha a kibocsátja 'error'
a EventEmitter
várakozás közben.
A Promise
feloldás az adott eseménynek kibocsátott összes argumentum tömbjével oldható fel.
Ez a módszer szándékosan általános, és az EventTarget webes platform felületével működik, amely nem rendelkezik speciális'error'
eseményszemantikákkal, és nem figyeli az eseményt 'error'
.
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);
}
Az esemény speciális kezelését 'error'
csak akkor használja a rendszer, ha events.once()
egy másik eseményre vár. Ha events.once()
magát azerror'
eseményt várja meg, akkor a rendszer bármilyen más típusú eseményként kezeli, különös kezelés nélkül:
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
Az AbortSignal
eseményre való várakozás megszakításához használható:
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[]>
Paraméterek
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string | symbol
- options
-
Pick<StaticEventEmitterOptions, "signal">
Válaszok
Promise<any[]>
Örökölt forrás InternalClient.once
once(EventTarget, string, StaticEventEmitterOptions)
static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>
Paraméterek
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterOptions
Válaszok
Promise<any[]>
Örökölt forrás InternalClient.once
once<K>(string | symbol, (args: any[]) => void)
Hozzáad egy egyszerilistener
függvényt a nevű eventName
eseményhez. A következő aktiváláskor eventName
a figyelő el lesz távolítva, majd meghívódik.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
A parancsra mutató hivatkozást ad vissza, hogy a EventEmitter
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<K>(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
Örökölt forrás InternalClient.once
open()
function open(): Promise<Connected>
Válaszok
Promise<Connected>
Örökölt forrás InternalClient.open
open(Callback<Connected>)
function open(openCallback: Callback<Connected>)
Paraméterek
- openCallback
-
Callback<Connected>
Örökölt forrás InternalClient.open
prependListener<K>(string | symbol, (args: any[]) => void)
Hozzáadja a listener
függvényt a nevű esemény eventName
figyelőtömbjének elejéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener
már hozzáadva van-e. Több hívás, amely ugyanazt a kombinációt eventName
adja át, és listener
ennek eredményeként a listener
rendszer többször is hozzáadja és meghívja őket.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
A parancsra mutató hivatkozást ad vissza, hogy a EventEmitter
hívások láncoltak legyenek.
function prependListener<K>(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
Örökölt forrás InternalClient.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
Hozzáad egy egyszerilistener
függvényt a nevesített eventName
eseményhez a figyelőtömb elejéhez . A következő aktiváláskor eventName
a figyelő el lesz távolítva, majd meghívódik.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
A parancsra mutató hivatkozást ad vissza, hogy a EventEmitter
hívások láncoltak legyenek.
function prependOnceListener<K>(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
Örökölt forrás InternalClient.prependOnceListener
rawListeners<K>(string | symbol)
A nevű esemény eventName
figyelőinek tömbjének másolatát adja vissza, beleértve a burkolókat is (például a által .once()
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<K>(eventName: string | symbol): Function[]
Paraméterek
- eventName
-
string | symbol
Válaszok
Function[]
Örökölt forrás InternalClient.rawListeners
reject(Message)
function reject(message: Message): Promise<MessageRejected>
Paraméterek
- message
- Message
Válaszok
Promise<MessageRejected>
Örökölt forrás InternalClient.reject
reject(Message, Callback<MessageRejected>)
function reject(message: Message, rejectCallback: Callback<MessageRejected>)
Paraméterek
- message
- Message
- rejectCallback
-
Callback<MessageRejected>
Örökölt forrás InternalClient.reject
removeAllListeners(string | symbol)
Eltávolítja az összes figyelőt vagy a megadott eventName
figyelőt.
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 parancsra mutató hivatkozást ad vissza, hogy a EventEmitter
hívások láncoltak legyenek.
function removeAllListeners(eventName?: string | symbol): ModuleClient
Paraméterek
- eventName
-
string | symbol
Válaszok
Örökölt forrás InternalClient.removeAllListeners
removeListener<K>(string | symbol, (args: any[]) => void)
Eltávolítja a megadott listener
értéket a nevű eventName
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 egy figyelőt többször is hozzáadtak a megadott eventName
figyelőtömbhöz, akkor removeListener()
az egyes példányok eltávolításához többször is meg kell hívni.
Az esemény kibocsátása után a rendszer a kibocsátáskor hozzá kapcsolt összes figyelőt sorrendben hívja meg. Ez azt jelenti, hogy a removeListener()
kibocsátás után és removeAllListeners()
az utolsó figyelő végrehajtása előtt indított hívások nem távolítják el őket a folyamatban lévőkbőlemit()
. 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 figyelők kezelése belső tömb használatával történik, a hívás megváltoztatja a figyelő eltávolítása után regisztrált figyelők pozícióindexeit. Ez nem befolyásolja a figyelők meghívásának sorrendjét, de ez azt jelenti, hogy a emitter.listeners()
metódus által visszaadott figyelőtömb minden példányát ú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()
a rendszer 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 parancsra mutató hivatkozást ad vissza, hogy a EventEmitter
hívások láncoltak legyenek.
function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): ModuleClient
Paraméterek
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Válaszok
Örökölt forrás InternalClient.removeListener
sendEvent(Message)
function sendEvent(message: Message): Promise<MessageEnqueued>
Paraméterek
- message
- Message
Válaszok
Promise<MessageEnqueued>
Örökölt forrás InternalClient.sendEvent
sendEvent(Message, Callback<MessageEnqueued>)
function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)
Paraméterek
- message
- Message
- sendEventCallback
-
Callback<MessageEnqueued>
Örökölt forrás InternalClient.sendEvent
sendEventBatch(Message[])
function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>
Paraméterek
- messages
-
Message[]
Válaszok
Promise<MessageEnqueued>
Örökölt forrás InternalClient.sendEventBatch
sendEventBatch(Message[], Callback<MessageEnqueued>)
function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)
Paraméterek
- messages
-
Message[]
- sendEventBatchCallback
-
Callback<MessageEnqueued>
Örökölt forrás InternalClient.sendEventBatch
setMaxListeners(number)
Alapértelmezés szerint EventEmitter
az s figyelmeztetést jelenít meg, ha egy adott eseményhez 10
több 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ó (vagy 0
) értékre Infinity
, amely korlátlan számú figyelőt jelez.
A parancsra mutató hivatkozást ad vissza, hogy a EventEmitter
hívások láncoltak legyenek.
function setMaxListeners(n: number): ModuleClient
Paraméterek
- n
-
number
Válaszok
Örökölt forrás 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)[])
Paraméterek
- n
-
number
Nem negatív szám. A figyelők maximális száma eseményenként EventTarget
.
- eventTargets
-
(EventEmitter<DefaultEventMap> | EventTarget)[]
Örökölt forrás InternalClient.setMaxListeners
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 az ExponentialBackoffWithJitter.
function setRetryPolicy(policy: RetryPolicy)
Paraméterek
- policy
-
RetryPolicy
{RetryPolicy} Az újrapróbálkozási szabályzat, amelyet az összes jövőbeli művelethez használni kell.
Örökölt forrás InternalClient.setRetryPolicy
setTransportOptions(any)
function setTransportOptions(options: any): Promise<TransportConfigured>
Paraméterek
- options
-
any
Válaszok
Promise<TransportConfigured>
Örökölt forrás InternalClient.setTransportOptions
setTransportOptions(any, Callback<TransportConfigured>)
function setTransportOptions(options: any, done: Callback<TransportConfigured>)
Paraméterek
- options
-
any
- done
-
Callback<TransportConfigured>
Örökölt forrás InternalClient.setTransportOptions
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)
Paraméterek
- sharedAccessSignature
-
string
- updateSasCallback
-
Callback<SharedAccessSignatureUpdated>
Örökölt forrás InternalClient.updateSharedAccessSignature
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)
function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)
Paraméterek
- error
-
Error
- event
-
string | symbol
- args
-
AnyRest
Örökölt forrás InternalClient.__@captureRejectionSymbol@145