Client class
Klient urządzenia usługi IoT Hub używany do łączenia urządzenia z centrum Azure IoT Hub.
Użytkownicy zestawu SDK powinni wywołać jedną z metod fabrycznych, z ConnectionString lub zsharedAccessSignature w celu utworzenia klienta urządzenia usługi IoT Hub.
- Rozszerzenie
-
InternalClient
Konstruktory
Client(Device |
Właściwości dziedziczone
capture |
Wartość: wartość logiczna Zmień domyślną opcję |
capture |
Wartość: Zobacz, jak napisać niestandardowy |
default |
Domyślnie dla dowolnego pojedynczego zdarzenia można zarejestrować maksymalnie Należy zachować ostrożność podczas ustawiania To nie jest twardy limit. Wystąpienie
Flaga wiersza polecenia Emitowane ostrzeżenie można sprawdzić za pomocą |
error |
Ten symbol służy do instalowania odbiornika tylko do monitorowania zdarzeń Instalowanie odbiornika przy użyciu tego symbolu nie zmienia zachowania po emitowaniu zdarzenia |
Metody
close() | |
close(Callback<Disconnected>) | Zamyka połączenie transportowe i niszczy zasoby klienta. Uwaga: po wywołaniu tej metody nie można ponownie użyć obiektu klienta. |
from |
Tworzy klienta urządzenia usługi IoT Hub na podstawie danej metody uwierzytelniania i przy użyciu danego typu transportu. |
from |
Tworzy klienta urządzenia usługi IoT Hub na podstawie podanych parametrów połączenia przy użyciu danego typu transportu. |
from |
Tworzy klienta urządzenia usługi IoT Hub na podstawie danego sygnatury dostępu współdzielonego przy użyciu danego typu transportu. |
get |
|
get |
|
notify |
|
notify |
Metoda |
on |
Rejestruje wywołanie zwrotne dla metody o nazwie |
set |
|
set |
|
upload |
|
upload |
Metoda |
Metody dziedziczone
abandon(Message) | |
abandon(Message, Callback<Message |
|
add |
Nasłuchuje raz zdarzenia Nasłuchiwanie zdarzenia Ten interfejs API umożliwia bezpieczne korzystanie z Zwraca jednorazowy element, aby można było go łatwiej anulować.
|
add |
Alias dla |
complete(Message) | |
complete(Message, Callback<Message |
|
emit<K>(string | symbol, Any |
Synchronicznie wywołuje każdy odbiornik zarejestrowany dla zdarzenia o nazwie Zwraca
|
event |
Zwraca tablicę z listą zdarzeń, dla których emiter zarejestrował odbiorniki. Wartości w tablicy to ciągi lub
|
get |
Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie W przypadku W przypadku
|
get |
Zwraca bieżącą wartość maksymalnego odbiornika dla |
get |
Zwraca obecnie ustawioną maksymalną ilość odbiorników. W przypadku W przypadku
|
get |
|
get |
|
listener |
Metoda klasy zwracająca liczbę odbiorników dla danego
|
listener |
Zwraca liczbę odbiorników nasłuchujących zdarzenia o nazwie |
listeners<K>(string | symbol) | Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie
|
off<K>(string | symbol, (args: any[]) => void) | Alias dla |
on(Event |
Zwraca Za pomocą
Użyj opcji
|
on(Event |
|
on<K>(string | symbol, (args: any[]) => void) | Dodaje funkcję
Zwraca odwołanie do Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę
|
once(Event |
Tworzy Ta metoda jest celowo ogólna i współpracuje z platformą internetową EventTarget interfejsu, który nie ma specjalnej semantyki zdarzeń
Specjalna obsługa zdarzenia
Za pomocą
|
once(Event |
|
once<K>(string | symbol, (args: any[]) => void) | Dodaje funkcję jednorazową
Zwraca odwołanie do Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę
|
open() | |
open(Callback<Connected>) | |
prepend |
Dodaje funkcję
Zwraca odwołanie do |
prepend |
Dodaje funkcję jednorazową
Zwraca odwołanie do |
raw |
Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie
|
reject(Message) | |
reject(Message, Callback<Message |
|
remove |
Usuwa wszystkie odbiorniki lub te z określonych Źle jest usunąć odbiorniki dodane gdzie indziej w kodzie, szczególnie w przypadku utworzenia wystąpienia Zwraca odwołanie do |
remove |
Usuwa określone
Po emitowaniu zdarzenia wszystkie odbiorniki dołączone do niego w momencie emitowania są wywoływane w kolejności. Oznacza to, że wszystkie wywołania
Ponieważ odbiorniki są zarządzane przy użyciu tablicy wewnętrznej, wywołanie spowoduje zmianę indeksów pozycji dowolnego odbiornika zarejestrowanego po usunięcia odbiornika. Nie będzie to miało wpływu na kolejność wywoływanych odbiorników, ale oznacza to, że wszystkie kopie tablicy odbiorników zwrócone przez metodę Gdy pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie),
Zwraca odwołanie do |
send |
|
send |
|
send |
|
send |
|
set |
Domyślnie Zwraca odwołanie do |
set |
|
set |
Ustawia zasady ponawiania prób używane przez klienta we wszystkich operacjach. Wartość domyślna to ExponentialBackoffWithJitter. |
set |
|
set |
|
update |
|
[capture |
Szczegóły konstruktora
Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)
new Client(transport: DeviceTransport, connStr?: string, blobUploadClient?: BlobUploadClient, fileUploadApi?: FileUploadInterface)
Parametry
- transport
- DeviceTransport
Obiekt, który implementuje interfejs oczekiwany przez obiekt transportu, np. http.
- connStr
-
string
Parametry połączenia (opcjonalnie: jeśli nie podano aktualizacjiSharedAccessSignature należy wywołać, aby bezpośrednio ustawić token SharedAccessSignature).
- blobUploadClient
-
BlobUploadClient
Obiekt, który może przekazać strumień do obiektu blob.
- fileUploadApi
-
FileUploadInterface
Obiekt używany do komunikowania się z usługą IoT Hub dla akcji związanych z usługą Blob Storage.
Szczegóły właściwości dziedziczonej
captureRejections
Wartość: wartość logiczna
Zmień domyślną opcję captureRejections
dla wszystkich nowych obiektów EventEmitter
.
static captureRejections: boolean
Wartość właściwości
boolean
dziedziczone z InternalClient.captureRejections
captureRejectionSymbol
Wartość: Symbol.for('nodejs.rejection')
Zobacz, jak napisać niestandardowy rejection handler
.
static captureRejectionSymbol: typeof captureRejectionSymbol
Wartość właściwości
typeof captureRejectionSymbol
dziedziczone z InternalClient.captureRejectionSymbol
defaultMaxListeners
Domyślnie dla dowolnego pojedynczego zdarzenia można zarejestrować maksymalnie 10
odbiorników. Ten limit można zmienić dla poszczególnych wystąpień EventEmitter
przy użyciu metody emitter.setMaxListeners(n)
. Aby zmienić ustawienie domyślne dla wszystkich wystąpieńEventEmitter
, można użyć właściwości events.defaultMaxListeners
. Jeśli ta wartość nie jest liczbą dodatnią, zostanie zgłoszony RangeError
.
Należy zachować ostrożność podczas ustawiania events.defaultMaxListeners
, ponieważ zmiana ma wpływ na wszystkich wystąpieńEventEmitter
, w tym utworzonych przed wprowadzeniem zmiany. Jednak wywołanie emitter.setMaxListeners(n)
nadal ma pierwszeństwo przed events.defaultMaxListeners
.
To nie jest twardy limit. Wystąpienie EventEmitter
umożliwi dodanie większej liczby odbiorników, ale wyświetli ostrzeżenie śledzenia do stderr wskazujące, że wykryto "możliwy wyciek pamięci eventEmitter". W przypadku dowolnego pojedynczego EventEmitter
można użyć metod emitter.getMaxListeners()
i emitter.setMaxListeners()
, aby tymczasowo uniknąć tego ostrzeżenia:
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));
});
Flaga wiersza polecenia --trace-warnings
może służyć do wyświetlania śladu stosu dla takich ostrzeżeń.
Emitowane ostrzeżenie można sprawdzić za pomocą process.on('warning')
i będzie mieć dodatkowe emitter
, type
i count
właściwości, odwołując się do wystąpienia emitera zdarzeń, nazwy zdarzenia i liczby dołączonych odbiorników, odpowiednio.
Właściwość name
jest ustawiona na wartość 'MaxListenersExceededWarning'
.
static defaultMaxListeners: number
Wartość właściwości
number
dziedziczone z InternalClient.defaultMaxListeners
errorMonitor
Ten symbol służy do instalowania odbiornika tylko do monitorowania zdarzeń 'error'
. Odbiorniki zainstalowane przy użyciu tego symbolu są wywoływane przed wywołaniami zwykłych odbiorników 'error'
.
Instalowanie odbiornika przy użyciu tego symbolu nie zmienia zachowania po emitowaniu zdarzenia 'error'
. W związku z tym proces będzie nadal ulegać awarii, jeśli nie zainstalowano zwykłego odbiornika 'error'
.
static errorMonitor: typeof errorMonitor
Wartość właściwości
typeof errorMonitor
dziedziczone z InternalClient.errorMonitor
Szczegóły metody
close()
function close(): Promise<Disconnected>
Zwraca
Promise<Disconnected>
close(Callback<Disconnected>)
Zamyka połączenie transportowe i niszczy zasoby klienta.
Uwaga: po wywołaniu tej metody nie można ponownie użyć obiektu klienta.
function close(closeCallback?: Callback<Disconnected>)
Parametry
- closeCallback
-
Callback<Disconnected>
Opcjonalna funkcja wywoływana po rozłączeniu transportu i zamknięciu klienta.
fromAuthenticationProvider(AuthenticationProvider, any)
Tworzy klienta urządzenia usługi IoT Hub na podstawie danej metody uwierzytelniania i przy użyciu danego typu transportu.
static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): Client
Parametry
- authenticationProvider
-
AuthenticationProvider
Obiekt używany do uzyskiwania parametrów uwierzytelniania dla centrum IoT.
- transportCtor
-
any
Protokół transportu używany do nawiązywania połączenia z centrum IoT Hub.
Zwraca
fromConnectionString(string, any)
Tworzy klienta urządzenia usługi IoT Hub na podstawie podanych parametrów połączenia przy użyciu danego typu transportu.
static function fromConnectionString(connStr: string, transportCtor: any): Client
Parametry
- connStr
-
string
Parametry połączenia, które hermetyzują uprawnienia "połączenie urządzenia" w centrum IoT.
- transportCtor
-
any
Konstruktor transportu.
Zwraca
fromSharedAccessSignature(string, any)
Tworzy klienta urządzenia usługi IoT Hub na podstawie danego sygnatury dostępu współdzielonego przy użyciu danego typu transportu.
static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): Client
Parametry
- sharedAccessSignature
-
string
Sygnatura dostępu współdzielonego, która hermetyzuje uprawnienia "łączenie urządzenia" w centrum IoT.
- transportCtor
-
any
Zwraca
getBlobSharedAccessSignature(string)
function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>
Parametry
- blobName
-
string
Zwraca
Promise<UploadParams>
getBlobSharedAccessSignature(string, Callback<UploadParams>)
getBlobSharedAccessSignature
pobiera połączony token SAS konta magazynu z usługi IoT Hub
function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)
Parametry
- blobName
-
string
Nazwa do użycia dla obiektu blob, który zostanie utworzony z zawartością strumienia.
- callback
-
Callback<UploadParams>
Opcjonalne wywołanie zwrotne do wywołania po zakończeniu przekazywania.
notifyBlobUploadStatus(string, boolean, number, string)
function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string): Promise<void>
Parametry
- correlationId
-
string
- isSuccess
-
boolean
- statusCode
-
number
- statusDescription
-
string
Zwraca
Promise<void>
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)
Metoda notifyBlobUploadStatus
wysyła do usługi IoT Hub wynik przekazywania obiektu blob.
function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)
Parametry
- correlationId
-
string
Identyfikator korelacji stanu przekazywania do określonego obiektu blob. Wygenerowano podczas wywołania metody getBlobSharedAccessSignature
.
- isSuccess
-
boolean
Wynik operacji obiektu blob magazynu o stanie powodzenia lub niepowodzenia.
- statusCode
-
number
Kod stanu HTTP skojarzony z wynikiem obiektu blob magazynu.
- statusDescription
-
string
Opis kodu stanu HTTP.
- callback
-
ErrorCallback
Opcjonalne wywołanie zwrotne do wywołania po zakończeniu przekazywania.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)
Rejestruje wywołanie zwrotne dla metody o nazwie methodName
.
function onDeviceMethod(methodName: string, callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)
Parametry
- methodName
-
string
Nazwa metody, która będzie obsługiwana przez wywołanie zwrotne
- callback
-
(request: DeviceMethodRequest, response: DeviceMethodResponse) => void
Funkcja, która jest wywoływana za każdym razem, gdy zostanie odebrane żądanie metody o nazwie methodName
.
setOptions(DeviceClientOptions)
function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>
Parametry
- options
- DeviceClientOptions
Zwraca
Promise<TransportConfigured>
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
function setOptions(options: DeviceClientOptions, done: Callback<TransportConfigured>)
Parametry
- options
- DeviceClientOptions
- done
-
Callback<TransportConfigured>
uploadToBlob(string, Stream, number)
function uploadToBlob(blobName: string, stream: Stream, streamLength: number): Promise<void>
Parametry
- blobName
-
string
- stream
-
Stream
- streamLength
-
number
Zwraca
Promise<void>
uploadToBlob(string, Stream, number, ErrorCallback)
Metoda uploadToBlob
przekazuje strumień do obiektu blob.
function uploadToBlob(blobName: string, stream: Stream, streamLength: number, callback: ErrorCallback)
Parametry
- blobName
-
string
Nazwa do użycia dla obiektu blob, który zostanie utworzony z zawartością strumienia.
- stream
-
Stream
Dane, które powinny zostać przekazane do obiektu blob.
- streamLength
-
number
Rozmiar danych, które powinny zostać przekazane do obiektu blob.
- callback
-
ErrorCallback
Szczegóły metody dziedziczonej
abandon(Message)
function abandon(message: Message): Promise<MessageAbandoned>
Parametry
- message
- Message
Zwraca
Promise<MessageAbandoned>
dziedziczone z InternalClient.abandon
abandon(Message, Callback<MessageAbandoned>)
function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)
Parametry
- message
- Message
- abandonCallback
-
Callback<MessageAbandoned>
dziedziczone z InternalClient.abandon
addAbortListener(AbortSignal, (event: Event) => void)
Nasłuchuje raz zdarzenia abort
w podanym signal
.
Nasłuchiwanie zdarzenia abort
na sygnałach przerwania jest niebezpieczne i może prowadzić do wycieków zasobów, ponieważ inna firma z sygnałem może wywołać e.stopImmediatePropagation()
. Niestety Node.js nie można tego zmienić, ponieważ narusza to standard sieci Web. Ponadto oryginalny interfejs API ułatwia zapominanie o usuwaniu odbiorników.
Ten interfejs API umożliwia bezpieczne korzystanie z AbortSignal
w interfejsach API Node.js przez rozwiązanie tych dwóch problemów przez nasłuchiwanie zdarzenia, tak aby stopImmediatePropagation
nie uniemożliwiał uruchamiania odbiornika.
Zwraca jednorazowy element, aby można było go łatwiej anulować.
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
Parametry
- signal
-
AbortSignal
- resource
-
(event: Event) => void
Zwraca
Disposable
Jednorazowe usunięcie odbiornika abort
.
dziedziczone z InternalClient.addAbortListener
addListener<K>(string | symbol, (args: any[]) => void)
Alias dla emitter.on(eventName, listener)
.
function addListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametry
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Zwraca
dziedziczone z InternalClient.addListener
complete(Message)
function complete(message: Message): Promise<MessageCompleted>
Parametry
- message
- Message
Zwraca
Promise<MessageCompleted>
dziedziczone z InternalClient.complete
complete(Message, Callback<MessageCompleted>)
function complete(message: Message, completeCallback: Callback<MessageCompleted>)
Parametry
- message
- Message
- completeCallback
-
Callback<MessageCompleted>
dziedziczone z InternalClient.complete
emit<K>(string | symbol, AnyRest)
Synchronicznie wywołuje każdy odbiornik zarejestrowany dla zdarzenia o nazwie eventName
, w kolejności, w której zostały zarejestrowane, przekazując podane argumenty do każdego.
Zwraca true
, jeśli zdarzenie miało odbiorniki, false
w przeciwnym razie.
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
Parametry
- eventName
-
string | symbol
- args
-
AnyRest
Zwraca
boolean
dziedziczone z InternalClient.emit
eventNames()
Zwraca tablicę z listą zdarzeń, dla których emiter zarejestrował odbiorniki. Wartości w tablicy to ciągi lub 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)[]
Zwraca
(string | symbol)[]
dziedziczone z InternalClient.eventNames
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)
Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName
.
W przypadku EventEmitter
działa to dokładnie tak samo jak wywoływanie .listeners
na emiterze.
W przypadku EventTarget
jest to jedyny sposób uzyskiwania odbiorników zdarzeń dla obiektu docelowego zdarzenia. Jest to przydatne do celów debugowania i diagnostyki.
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[]
Parametry
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
- name
-
string | symbol
Zwraca
Function[]
dziedziczone z InternalClient.getEventListeners
getMaxListeners()
Zwraca bieżącą wartość maksymalnego odbiornika dla EventEmitter
, która jest ustawiona przez emitter.setMaxListeners(n)
lub domyślnie domyślneMaxListeners.
function getMaxListeners(): number
Zwraca
number
dziedziczone z InternalClient.getMaxListeners
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)
Zwraca obecnie ustawioną maksymalną ilość odbiorników.
W przypadku EventEmitter
działa to dokładnie tak samo jak wywoływanie .getMaxListeners
na emiterze.
W przypadku EventTarget
jest to jedyny sposób uzyskania maksymalnej liczby odbiorników zdarzeń dla celu zdarzenia. Jeśli liczba procedur obsługi zdarzeń w pojedynczym obiekcie EventTarget przekroczy maksymalny zestaw, usługa EventTarget wyświetli ostrzeżenie.
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
Parametry
- emitter
-
EventEmitter<DefaultEventMap> | EventTarget
Zwraca
number
dziedziczone z InternalClient.getMaxListeners
getTwin()
getTwin(Callback<Twin>)
function getTwin(done: Callback<Twin>)
Parametry
- done
-
Callback<Twin>
dziedziczone z InternalClient.getTwin
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)
Ostrzeżenie
Ten interfejs API jest już przestarzały.
Since v3.2.0 - Use listenerCount
instead.
Metoda klasy zwracająca liczbę odbiorników dla danego eventName
zarejestrowanego w danym 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
Parametry
- emitter
-
EventEmitter<DefaultEventMap>
Emiter do wykonywania zapytania
- eventName
-
string | symbol
Nazwa zdarzenia
Zwraca
number
dziedziczone z InternalClient.listenerCount
listenerCount<K>(string | symbol, Function)
Zwraca liczbę odbiorników nasłuchujących zdarzenia o nazwie eventName
.
W przypadku podania listener
zostanie zwrócona liczba znalezionych odbiorników na liście odbiorników zdarzenia.
function listenerCount<K>(eventName: string | symbol, listener?: Function): number
Parametry
- eventName
-
string | symbol
Nazwa zdarzenia, dla których jest nasłuchiwane
- listener
-
Function
Funkcja obsługi zdarzeń
Zwraca
number
dziedziczone z InternalClient.listenerCount
listeners<K>(string | symbol)
Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie 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[]
Parametry
- eventName
-
string | symbol
Zwraca
Function[]
dziedziczone z InternalClient.listeners
off<K>(string | symbol, (args: any[]) => void)
Alias dla emitter.removeListener()
.
function off<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametry
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Zwraca
dziedziczone z InternalClient.off
on(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions)
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
Zwraca AsyncIterator
, który iteruje eventName
zdarzeń. Zostanie on zgłoszony, jeśli EventEmitter
emituje 'error'
. Usuwa wszystkie odbiorniki podczas zamykania pętli.
value
zwracana przez każdą iterację jest tablicą składającą się z emitowanych argumentów zdarzeń.
Za pomocą AbortSignal
można anulować oczekiwanie na zdarzenia:
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());
Użyj opcji close
, aby określić tablicę nazw zdarzeń, które zakończą iterację:
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
ee.emit('close');
});
for await (const event of on(ee, 'foo', { close: ['close'] })) {
console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>
Parametry
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string | symbol
- options
-
StaticEventEmitterIteratorOptions
Zwraca
AsyncIterator<any[], any, any>
AsyncIterator
, który iteruje eventName
zdarzenia emitowane przez emitter
dziedziczone z InternalClient.on
on(EventTarget, string, StaticEventEmitterIteratorOptions)
static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>
Parametry
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterIteratorOptions
Zwraca
AsyncIterator<any[], any, any>
dziedziczone z InternalClient.on
on<K>(string | symbol, (args: any[]) => void)
Dodaje funkcję listener
na końcu tablicy odbiorników dla zdarzenia o nazwie eventName
. Nie są sprawdzane, czy listener
został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName
i listener
spowoduje dodanie listener
i wywołanie wielu razy.
server.on('connection', (stream) => {
console.log('someone connected!');
});
Zwraca odwołanie do EventEmitter
, aby wywołania mogły być łańcuchowe.
Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependListener()
można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
function on<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametry
- eventName
-
string | symbol
Nazwa zdarzenia.
- listener
-
(args: any[]) => void
Funkcja wywołania zwrotnego
Zwraca
dziedziczone z InternalClient.on
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)
Tworzy Promise
, który jest spełniony, gdy EventEmitter
emituje dane zdarzenie lub jest odrzucany, jeśli EventEmitter
emituje 'error'
podczas oczekiwania.
Promise
rozwiąże problem z tablicą wszystkich argumentów emitowanych do danego zdarzenia.
Ta metoda jest celowo ogólna i współpracuje z platformą internetową EventTarget interfejsu, który nie ma specjalnej semantyki zdarzeń'error'
i nie nasłuchuje zdarzenia '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);
}
Specjalna obsługa zdarzenia 'error'
jest używana tylko wtedy, gdy events.once()
jest używana do oczekiwania na inne zdarzenie. Jeśli events.once()
jest używana do oczekiwania na samo zdarzenieerror'
, jest traktowany jako dowolny inny rodzaj zdarzenia bez specjalnej obsługi:
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
Za pomocą AbortSignal
można anulować oczekiwanie na zdarzenie:
import { EventEmitter, once } from 'node:events';
const ee = new EventEmitter();
const ac = new AbortController();
async function foo(emitter, event, signal) {
try {
await once(emitter, event, { signal });
console.log('event emitted!');
} catch (error) {
if (error.name === 'AbortError') {
console.error('Waiting for the event was canceled!');
} else {
console.error('There was an error', error.message);
}
}
}
foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
static function once(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>
Parametry
- emitter
-
EventEmitter<DefaultEventMap>
- eventName
-
string | symbol
- options
-
StaticEventEmitterOptions
Zwraca
Promise<any[]>
dziedziczone z InternalClient.once
once(EventTarget, string, StaticEventEmitterOptions)
static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>
Parametry
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterOptions
Zwraca
Promise<any[]>
dziedziczone z InternalClient.once
once<K>(string | symbol, (args: any[]) => void)
Dodaje funkcję jednorazowąlistener
dla zdarzenia o nazwie eventName
. Przy następnym wyzwoleniu eventName
ten odbiornik zostanie usunięty, a następnie wywołany.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Zwraca odwołanie do EventEmitter
, aby wywołania mogły być łańcuchowe.
Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependOnceListener()
można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
function once<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametry
- eventName
-
string | symbol
Nazwa zdarzenia.
- listener
-
(args: any[]) => void
Funkcja wywołania zwrotnego
Zwraca
dziedziczone z InternalClient.once
open()
function open(): Promise<Connected>
Zwraca
Promise<Connected>
dziedziczone z InternalClient.open
open(Callback<Connected>)
function open(openCallback: Callback<Connected>)
Parametry
- openCallback
-
Callback<Connected>
dziedziczone z InternalClient.open
prependListener<K>(string | symbol, (args: any[]) => void)
Dodaje funkcję listener
do rozpoczynającej się tablicy odbiorników dla zdarzenia o nazwie eventName
. Nie są sprawdzane, czy listener
został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName
i listener
spowoduje dodanie listener
i wywołanie wielu razy.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
Zwraca odwołanie do EventEmitter
, aby wywołania mogły być łańcuchowe.
function prependListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametry
- eventName
-
string | symbol
Nazwa zdarzenia.
- listener
-
(args: any[]) => void
Funkcja wywołania zwrotnego
Zwraca
dziedziczone z InternalClient.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
Dodaje funkcję jednorazowąlistener
dla zdarzenia o nazwie eventName
do rozpoczynającej się tablicy odbiorników. Następnym razem, gdy eventName
zostanie wyzwolony, ten odbiornik zostanie usunięty, a następnie wywołany.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Zwraca odwołanie do EventEmitter
, aby wywołania mogły być łańcuchowe.
function prependOnceListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametry
- eventName
-
string | symbol
Nazwa zdarzenia.
- listener
-
(args: any[]) => void
Funkcja wywołania zwrotnego
Zwraca
dziedziczone z InternalClient.prependOnceListener
rawListeners<K>(string | symbol)
Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName
, w tym wszelkie otoki (takie jak te utworzone przez .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[]
Parametry
- eventName
-
string | symbol
Zwraca
Function[]
dziedziczone z InternalClient.rawListeners
reject(Message)
function reject(message: Message): Promise<MessageRejected>
Parametry
- message
- Message
Zwraca
Promise<MessageRejected>
dziedziczone z InternalClient.reject
reject(Message, Callback<MessageRejected>)
function reject(message: Message, rejectCallback: Callback<MessageRejected>)
Parametry
- message
- Message
- rejectCallback
-
Callback<MessageRejected>
dziedziczone z InternalClient.reject
removeAllListeners(string | symbol)
Usuwa wszystkie odbiorniki lub te z określonych eventName
.
Źle jest usunąć odbiorniki dodane gdzie indziej w kodzie, szczególnie w przypadku utworzenia wystąpienia EventEmitter
przez inny składnik lub moduł (np. gniazda lub strumienie plików).
Zwraca odwołanie do EventEmitter
, aby wywołania mogły być łańcuchowe.
function removeAllListeners(eventName?: string | symbol): Client
Parametry
- eventName
-
string | symbol
Zwraca
dziedziczone z InternalClient.removeAllListeners
removeListener<K>(string | symbol, (args: any[]) => void)
Usuwa określone listener
z tablicy odbiorników dla zdarzenia o nazwie eventName
.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
removeListener()
usunie co najwyżej jedno wystąpienie odbiornika z tablicy odbiornika. Jeśli jakikolwiek pojedynczy odbiornik został dodany wiele razy do tablicy odbiornika dla określonego eventName
, removeListener()
należy wywołać wiele razy, aby usunąć każde wystąpienie.
Po emitowaniu zdarzenia wszystkie odbiorniki dołączone do niego w momencie emitowania są wywoływane w kolejności. Oznacza to, że wszystkie wywołania removeListener()
lub removeAllListeners()
po emitowaniu i przed ostatnie wykonanie odbiornika nie spowoduje usunięcia ich zemit()
w toku. Kolejne zdarzenia zachowują się zgodnie z oczekiwaniami.
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
Ponieważ odbiorniki są zarządzane przy użyciu tablicy wewnętrznej, wywołanie spowoduje zmianę indeksów pozycji dowolnego odbiornika zarejestrowanego po usunięcia odbiornika. Nie będzie to miało wpływu na kolejność wywoływanych odbiorników, ale oznacza to, że wszystkie kopie tablicy odbiorników zwrócone przez metodę emitter.listeners()
będą musiały zostać ponownie odtworzone.
Gdy pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie), removeListener()
usunie ostatnio dodane wystąpienie. W przykładzie odbiornik once('ping')
zostanie usunięty:
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');
Zwraca odwołanie do EventEmitter
, aby wywołania mogły być łańcuchowe.
function removeListener<K>(eventName: string | symbol, listener: (args: any[]) => void): Client
Parametry
- eventName
-
string | symbol
- listener
-
(args: any[]) => void
Zwraca
dziedziczone z InternalClient.removeListener
sendEvent(Message)
function sendEvent(message: Message): Promise<MessageEnqueued>
Parametry
- message
- Message
Zwraca
Promise<MessageEnqueued>
dziedziczone z InternalClient.sendEvent
sendEvent(Message, Callback<MessageEnqueued>)
function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)
Parametry
- message
- Message
- sendEventCallback
-
Callback<MessageEnqueued>
dziedziczone z InternalClient.sendEvent
sendEventBatch(Message[])
function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>
Parametry
- messages
-
Message[]
Zwraca
Promise<MessageEnqueued>
dziedziczone z InternalClient.sendEventBatch
sendEventBatch(Message[], Callback<MessageEnqueued>)
function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)
Parametry
- messages
-
Message[]
- sendEventBatchCallback
-
Callback<MessageEnqueued>
dziedziczone z InternalClient.sendEventBatch
setMaxListeners(number)
Domyślnie EventEmitter
s wyświetli ostrzeżenie, jeśli dla określonego zdarzenia zostanie dodane więcej niż 10
odbiorniki. Jest to przydatna wartość domyślna, która ułatwia znajdowanie przecieków pamięci. Metoda emitter.setMaxListeners()
umożliwia zmodyfikowanie limitu dla tego konkretnego wystąpienia EventEmitter
. Wartość można ustawić na Infinity
(lub 0
), aby wskazać nieograniczoną liczbę odbiorników.
Zwraca odwołanie do EventEmitter
, aby wywołania mogły być łańcuchowe.
function setMaxListeners(n: number): Client
Parametry
- n
-
number
Zwraca
dziedziczone z 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)[])
Parametry
- n
-
number
Liczba nieujemna. Maksymalna liczba odbiorników na zdarzenie EventTarget
.
- eventTargets
-
(EventEmitter<DefaultEventMap> | EventTarget)[]
Zero lub więcej wystąpień {EventTarget} lub {EventEmitter}. Jeśli żadna z nich nie zostanie określona, n
zostanie ustawiona jako domyślna wartość maksymalna dla wszystkich nowo utworzonych obiektów {EventTarget} i {EventEmitter}.
dziedziczone z InternalClient.setMaxListeners
setRetryPolicy(RetryPolicy)
Ustawia zasady ponawiania prób używane przez klienta we wszystkich operacjach. Wartość domyślna to ExponentialBackoffWithJitter.
function setRetryPolicy(policy: RetryPolicy)
Parametry
- policy
-
RetryPolicy
{RetryPolicy} Zasady ponawiania, które powinny być używane dla wszystkich przyszłych operacji.
dziedziczone z InternalClient.setRetryPolicy
setTransportOptions(any)
function setTransportOptions(options: any): Promise<TransportConfigured>
Parametry
- options
-
any
Zwraca
Promise<TransportConfigured>
dziedziczone z InternalClient.setTransportOptions
setTransportOptions(any, Callback<TransportConfigured>)
function setTransportOptions(options: any, done: Callback<TransportConfigured>)
Parametry
- options
-
any
- done
-
Callback<TransportConfigured>
dziedziczone z InternalClient.setTransportOptions
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)
Parametry
- sharedAccessSignature
-
string
- updateSasCallback
-
Callback<SharedAccessSignatureUpdated>
dziedziczone z InternalClient.updateSharedAccessSignature
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)
function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)
Parametry
- error
-
Error
- event
-
string | symbol
- args
-
AnyRest
dziedziczone z InternalClient.__@captureRejectionSymbol@141