ModuleClient class

  • Odwołanie
Pakiet:
azure-iot-device

IoT Hub klient urządzenia używany do łączenia urządzenia z usługą Azure IoT Hub.

Użytkownicy zestawu SDK powinni wywołać jedną z metod fabrycznych z pozycjiConnectionString lub zSharedAccessSignature w celu utworzenia klienta urządzenia IoT Hub.

Extends

InternalClient

Właściwości dziedziczone

captureRejections

Wartość: wartość logiczna

Zmień opcję domyślną captureRejections dla wszystkich nowych EventEmitter obiektów.
captureRejectionSymbol

Wartość: Symbol.for('nodejs.rejection')

Zobacz, jak napisać niestandardowy rejection handlerelement .
defaultMaxListeners

Domyślnie dla każdego pojedynczego 10 zdarzenia można zarejestrować maksymalnie odbiorniki. Ten limit można zmienić dla poszczególnych EventEmitter wystąpień przy użyciu emitter.setMaxListeners(n) metody . Aby zmienić wartość domyślną dla wszystkichEventEmitter wystąpień, events.defaultMaxListeners można użyć właściwości . Jeśli ta wartość nie jest liczbą dodatnią, RangeError zwracana jest wartość .

Zachowaj ostrożność podczas ustawiania events.defaultMaxListeners elementu , ponieważ zmiana ma wpływ na wszystkieEventEmitter wystąpienia, w tym te utworzone przed wprowadzeniem zmiany. Jednak wywołanie emitter.setMaxListeners(n) nadal ma pierwszeństwo przed events.defaultMaxListeners.

Nie jest to sztywny 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 EventEmitteremitter.getMaxListeners() elementu można użyć metod iemitter.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 --trace-warnings wiersza polecenia 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') elementu i będzie mieć dodatkowe emitterwłaściwości , typei count odwołujące się do wystąpienia emitera zdarzeń, nazwy zdarzenia i liczby dołączonych odbiorników, odpowiednio. Jej name właściwość jest ustawiona na 'MaxListenersExceededWarning'wartość .
errorMonitor

Ten symbol służy do instalowania odbiornika tylko do monitorowania 'error' zdarzeń. Odbiorniki zainstalowane przy użyciu tego symbolu są wywoływane przed wywołaniami zwykłych 'error' odbiorników.

Instalowanie odbiornika przy użyciu tego symbolu nie zmienia zachowania po 'error' emitowaniu zdarzenia. W związku z tym proces będzie nadal ulegać awarii, jeśli nie zainstalowano zwykłego 'error' odbiornika.

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 ModuleClient.
fromAuthenticationProvider(AuthenticationProvider, any)

Tworzy klienta modułu IoT Hub na podstawie danej metody uwierzytelniania i przy użyciu danego typu transportu.
fromConnectionString(string, any)

Tworzy klienta urządzenia IoT Hub na podstawie danego parametry połączenia przy użyciu danego typu transportu.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)

Tworzy klienta modułu IoT Hub przy użyciu informacji o konfiguracji ze środowiska.

Jeśli zmienna środowiskowa o nazwie EdgeHubConnectionString lub IotHubConnectionString istnieje, ta wartość jest używana i zachowanie jest identyczne z wywołaniem fromConnectionString przekazywania tego elementu. Jeśli te zmienne środowiskowe nie istnieją, należy zdefiniować następujące zmienne:

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

Tworzy klienta modułu IoT Hub na podstawie podanego sygnatury dostępu współdzielonego przy użyciu danego typu transportu.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)

Wywołuje metodę na urządzeniu podrzędnym lub w innym module na tym samym urządzeniu IoTEdge. Należy pamiętać, że ta funkcja działa tylko wtedy, gdy moduł jest uruchamiany jako część urządzenia IoTEdge.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Rejestruje wywołanie zwrotne dla metody o nazwie methodName.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Wysyła zdarzenie do danych wyjściowych danego modułu
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Wysyła tablicę zdarzeń do danych wyjściowych danego modułu
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Przekazuje opcje do ModuleClient obiektu, który może służyć do konfigurowania transportu.

Metody dziedziczone

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addAbortListener(AbortSignal, (event: Event) => void)

Nasłuchuje raz zdarzenia abort w podanym signalobiekcie .

abort Nasłuchiwanie zdarzenia na sygnałach przerwania jest niebezpieczne i może prowadzić do wycieków zasobów, ponieważ inna strona z sygnałem może wywołać e.stopImmediatePropagation()metodę . Niestety Node.js nie może to zmienić, ponieważ naruszałoby standard sieci Web. Ponadto oryginalny interfejs API ułatwia zapomnienie o usuwaniu odbiorników.

Ten interfejs API umożliwia bezpieczne korzystanie z AbortSignalusług s w interfejsach API Node.js przez rozwiązanie tych dwóch problemów przez nasłuchiwanie zdarzenia, które 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]();
  }
}
addListener<K>(string | symbol, (args: any[]) => void)

Alias dla emitter.on(eventName, listener).
complete(Message)
complete(Message, Callback<MessageCompleted>)
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 z nich.

Zwraca wartość true , jeśli zdarzenie ma 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
eventNames()

Zwraca tablicę zawierającą listę zdarzeń, dla których emiter zarejestrował odbiorniki. Wartości w tablicy to ciągi lub Symbols.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
getEventListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget, string | symbol)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

W przypadku EventEmitterfunkcji s zachowuje się dokładnie tak samo jak wywoływanie .listeners emitera.

Dla EventTargets jest to jedyny sposób, aby uzyskać odbiorniki zdarzeń dla celu 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] ]
}
getMaxListeners()

Zwraca bieżącą wartość maksymalnego odbiornika dla wartości, która EventEmitter jest ustawiona domyślnie emitter.setMaxListeners(n) na wartość defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)

Zwraca obecnie ustawioną maksymalną ilość odbiorników.

W przypadku EventEmitterfunkcji s zachowuje się dokładnie tak samo jak wywoływanie .getMaxListeners emitera.

Dla EventTargets jest to jedyny sposób uzyskiwania maksymalnych odbiorników zdarzeń dla docelowego zdarzenia. Jeśli liczba procedur obsługi zdarzeń w pojedynczym obiekcie EventTarget przekracza 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
}
getTwin()
getTwin(Callback<Twin>)
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Metoda klasy zwracająca liczbę odbiorników dla danego eventName zarejestrowanego w danym emitterobiekcie .

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
listenerCount<K>(string | symbol, Function)

Zwraca liczbę odbiorników nasłuchujących dla zdarzenia o nazwie eventName. Jeśli listener zostanie podana, zwróci liczbę znalezionych odbiorników na liście odbiorników zdarzenia.
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] ]
off<K>(string | symbol, (args: any[]) => void)

Alias dla emitter.removeListener().
on(EventEmitter<DefaultEventMap>, string, 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

AsyncIterator Zwraca zdarzenia, które iterują eventName zdarzenia. Zostanie on zgłoszony, jeśli EventEmitter emituje 'error'wartość . Usuwa wszystkie odbiorniki podczas zamykania pętli. Zwracana value przez każdą iterację jest tablicą składającą się z emitowanych argumentów zdarzeń.

Może AbortSignal służyć do anulowania oczekiwania 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());
on<K>(string | symbol, (args: any[]) => void)

listener Dodaje funkcję na końcu tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane w celu sprawdzenia, czy listener element został już dodany. Wiele wywołań eventName przekazujących tę samą kombinację i listener spowoduje listener dodanie i wywołanie ich wiele razy.

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

Zwraca odwołanie do elementu EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności ich dodawania. Metoda emitter.prependListener() może służyć jako alternatywa do dodawania odbiornika 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
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

Promise Tworzy obiekt, który jest spełniony, gdy EventEmitter emituje podane zdarzenie lub jest odrzucany, jeśli EventEmitter emituje 'error' się podczas oczekiwania. Element Promise zostanie rozpoznany za pomocą tablicy wszystkich argumentów emitowanych do danego zdarzenia.

Ta metoda jest celowo ogólna i współpracuje z interfejsem EventTarget platformy internetowej, który nie ma specjalnych'error' semantyki zdarzeń i nie nasłuchuje 'error' zdarzenia.

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 'error' zdarzenia jest używana tylko wtedy, gdy events.once() jest używana do oczekiwania na inne zdarzenie. Jeśli events.once() jest używany do oczekiwania na samo zdarzenie "error' , 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

Element AbortSignal może służyć do anulowania oczekiwania 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!
once(_DOMEventTarget, string, StaticEventEmitterOptions)
once<K>(string | symbol, (args: any[]) => void)

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName. Przy następnym eventName wyzwoleniu 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 elementu EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności ich dodawania. Metoda emitter.prependOnceListener() może służyć jako alternatywa do dodawania odbiornika 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
open()
open(Callback<Connected>)
prependListener<K>(string | symbol, (args: any[]) => void)

listener Dodaje funkcję na początku tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane w celu sprawdzenia, czy listener element został już dodany. Wiele wywołań eventName przekazujących tę samą kombinację i listener spowoduje listener dodanie i wywołanie ich wiele razy.

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

Zwraca odwołanie do elementu EventEmitter, aby wywołania mogły być łańcuchowe.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Dodaje jednorazowąlistener funkcję zdarzenia o nazwie eventName na początku tablicy odbiorników. Przy następnym eventName wyzwoleniu 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 elementu EventEmitter, aby wywołania mogły być łańcuchowe.
rawListeners<K>(string | symbol)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName, w tym wszelkie otoki (takie jak utworzone przez .once()program ).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
reject(Message)
reject(Message, Callback<MessageRejected>)
removeAllListeners(string | symbol)

Usuwa wszystkie odbiorniki lub te z określonego eventNameelementu .

Niewłaściwą praktyką jest usunięcie odbiorników dodanych w innym miejscu w kodzie, szczególnie w przypadku EventEmitter utworzenia wystąpienia przez inny składnik lub moduł (np. gniazda lub strumienie plików).

Zwraca odwołanie do elementu EventEmitter, aby można było połączyć wywołania w łańcuch.
removeListener<K>(string | symbol, (args: any[]) => void)

Usuwa określony listener element 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() spowoduje usunięcie co najwyżej jednego wystąpienia odbiornika z tablicy odbiornika. Jeśli którykolwiek pojedynczy odbiornik został dodany wiele razy do tablicy odbiornika dla określonego eventNameelementu , 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 removeListener() wywołania lub removeAllListeners()po emitowaniu i przed zakończeniem wykonywania ostatniego odbiornika nie zostaną usunięte zemit() postępu. 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 tej funkcji spowoduje zmianę indeksów pozycji każdego odbiornika zarejestrowanego po usunięciu 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 emitter.listeners() metodę będą musiały zostać ponownie odtworzone.

Jeśli pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie), removeListener() spowoduje usunięcie ostatnio dodanego wystąpienia. W przykładzie odbiornik once('ping') jest usuwany:

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 elementu EventEmitter, aby można było połączyć wywołania w łańcuch.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

Domyślnie EventEmitterprogram wyświetli ostrzeżenie, jeśli dla określonego zdarzenia zostanie dodanych więcej niż 10 odbiorniki. Jest to przydatne ustawienie domyślne, które pomaga znaleźć przecieki pamięci. Metoda emitter.setMaxListeners() umożliwia zmodyfikowanie limitu dla tego konkretnego EventEmitter wystąpienia. Wartość można ustawić na Infinity (lub 0), aby wskazać nieograniczoną liczbę odbiorników.

Zwraca odwołanie do elementu EventEmitter, aby można było połączyć wywołania w łańcuch.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | _DOMEventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);
setRetryPolicy(RetryPolicy)

Ustawia zasady ponawiania prób używane przez klienta we wszystkich operacjach. Wartość domyślna to ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Szczegóły właściwości dziedziczonej

captureRejections

Wartość: wartość logiczna

Zmień opcję domyślną captureRejections dla wszystkich nowych EventEmitter obiektów.

static captureRejections: boolean

Wartość właściwości

boolean

Dziedziczone z InternalClient.captureRejections

captureRejectionSymbol

Wartość: Symbol.for('nodejs.rejection')

Zobacz, jak napisać niestandardowy rejection handlerelement .

static captureRejectionSymbol: typeof captureRejectionSymbol

Wartość właściwości

typeof captureRejectionSymbol

Dziedziczone z InternalClient.captureRejectionSymbol

defaultMaxListeners

Domyślnie dla każdego pojedynczego 10 zdarzenia można zarejestrować maksymalnie odbiorniki. Ten limit można zmienić dla poszczególnych EventEmitter wystąpień przy użyciu emitter.setMaxListeners(n) metody . Aby zmienić wartość domyślną dla wszystkichEventEmitter wystąpień, events.defaultMaxListeners można użyć właściwości . Jeśli ta wartość nie jest liczbą dodatnią, RangeError zwracana jest wartość .

Zachowaj ostrożność podczas ustawiania events.defaultMaxListeners elementu , ponieważ zmiana ma wpływ na wszystkieEventEmitter wystąpienia, w tym te utworzone przed wprowadzeniem zmiany. Jednak wywołanie emitter.setMaxListeners(n) nadal ma pierwszeństwo przed events.defaultMaxListeners.

Nie jest to sztywny 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 EventEmitteremitter.getMaxListeners() elementu można użyć metod iemitter.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 --trace-warnings wiersza polecenia 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') elementu i będzie mieć dodatkowe emitterwłaściwości , typei count odwołujące się do wystąpienia emitera zdarzeń, nazwy zdarzenia i liczby dołączonych odbiorników, odpowiednio. Jej name właściwość jest ustawiona na 'MaxListenersExceededWarning'wartość .

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 'error' zdarzeń. Odbiorniki zainstalowane przy użyciu tego symbolu są wywoływane przed wywołaniami zwykłych 'error' odbiorników.

Instalowanie odbiornika przy użyciu tego symbolu nie zmienia zachowania po 'error' emitowaniu zdarzenia. W związku z tym proces będzie nadal ulegać awarii, jeśli nie zainstalowano zwykłego 'error' odbiornika.

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 ModuleClient.

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 modułu IoT Hub na podstawie danej metody uwierzytelniania i przy użyciu danego typu transportu.

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

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 usługą IoT Hub.

Zwraca

ModuleClient

fromConnectionString(string, any)

Tworzy klienta urządzenia IoT Hub na podstawie danego parametry połączenia przy użyciu danego typu transportu.

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

Parametry

connStr

string

Parametry połączenia, który hermetyzuje uprawnienia "połączenie urządzenia" w centrum IoT.

transportCtor

any

Konstruktor transportu.

Zwraca

ModuleClient

fromEnvironment(any) 

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

Parametry

transportCtor

any

Zwraca

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Tworzy klienta modułu IoT Hub przy użyciu informacji o konfiguracji ze środowiska.

Jeśli zmienna środowiskowa o nazwie EdgeHubConnectionString lub IotHubConnectionString istnieje, ta wartość jest używana i zachowanie jest identyczne z wywołaniem fromConnectionString przekazywania tego elementu. Jeśli te zmienne środowiskowe nie istnieją, należy zdefiniować następujące zmienne:

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

Parametry

transportCtor

any

Protokół transportu używany do nawiązywania połączenia z usługą IoT Hub.

callback

Callback<ModuleClient>

Opcjonalne wywołanie zwrotne do wywołania, gdy element ModuleClient został skonstruowany lub jeśli podczas tworzenia klienta wystąpi błąd.

fromSharedAccessSignature(string, any)

Tworzy klienta modułu IoT Hub na podstawie podanego sygnatury dostępu współdzielonego przy użyciu danego typu transportu.

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

Parametry

sharedAccessSignature

string

Sygnatura dostępu współdzielonego, która hermetyzuje uprawnienia "połączenie urządzenia" w centrum IoT.

transportCtor

any

Zwraca

ModuleClient

invokeMethod(string, MethodParams) 

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

Parametry

deviceId

string

methodParams

MethodParams

Zwraca

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Wywołuje metodę na urządzeniu podrzędnym lub w innym module na tym samym urządzeniu IoTEdge. Należy pamiętać, że ta funkcja działa tylko wtedy, gdy moduł jest uruchamiany jako część urządzenia IoTEdge.

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

Parametry

deviceId

string

identyfikator urządzenia docelowego

methodParams

MethodParams

parametry wywołania metody bezpośredniej

callback

Callback<MethodResult>

opcjonalne wywołanie zwrotne, które zostanie wywołane z obiektem Error lub wynikiem wywołania metody.

invokeMethod(string, string, MethodParams) 

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

Parametry

deviceId

string

moduleId

string

methodParams

MethodParams

Zwraca

Promise<MethodResult>

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

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

Parametry

deviceId

string

moduleId

string

methodParams

MethodParams

callback

Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Rejestruje wywołanie zwrotne dla metody o nazwie methodName.

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

Parametry

methodName

string

Nazwa metody, która będzie obsługiwana przez wywołanie zwrotne

callback

DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

Funkcja, która jest wywoływana za każdym razem, gdy zostanie odebrane żądanie metody dla metody o nazwie methodName .

sendOutputEvent(string, Message) 

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

Parametry

outputName

string

message
Message

Zwraca

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Wysyła zdarzenie do danych wyjściowych danego modułu

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

Parametry

outputName

string

Nazwa danych wyjściowych do wysłania zdarzenia do

message
Message

Komunikat do wysłania do danych wyjściowych

callback

Callback<MessageEnqueued>

Opcjonalna funkcja wywoływana, gdy operacja została w kolejce.

sendOutputEventBatch(string, Message[]) 

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

Parametry

outputName

string

messages

Message[]

Zwraca

Promise<MessageEnqueued>

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

Wysyła tablicę zdarzeń do danych wyjściowych danego modułu

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

Parametry

outputName

string

Nazwa danych wyjściowych do wysyłania zdarzeń do

messages

Message[]

callback

Callback<MessageEnqueued>

Funkcja do wywoływania, gdy operacje zostały w kolejce.

setOptions(DeviceClientOptions) 

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

Parametry

options
DeviceClientOptions

Zwraca

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Przekazuje opcje do ModuleClient obiektu, który może służyć do konfigurowania transportu.

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

Parametry

options
DeviceClientOptions

Obiekt DeviceClientOptions .

done

Callback<TransportConfigured>

Opcjonalne wywołanie zwrotne do wywołania po ustawieniu opcji.

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 signalobiekcie .

abort Nasłuchiwanie zdarzenia na sygnałach przerwania jest niebezpieczne i może prowadzić do wycieków zasobów, ponieważ inna strona z sygnałem może wywołać e.stopImmediatePropagation()metodę . Niestety Node.js nie może to zmienić, ponieważ naruszałoby standard sieci Web. Ponadto oryginalny interfejs API ułatwia zapomnienie o usuwaniu odbiorników.

Ten interfejs API umożliwia bezpieczne korzystanie z AbortSignalusług s w interfejsach API Node.js przez rozwiązanie tych dwóch problemów przez nasłuchiwanie zdarzenia, które 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

Jednorazowy abort , który usuwa odbiornik.

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

ModuleClient

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 z nich.

Zwraca wartość true , jeśli zdarzenie ma 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ę zawierającą listę zdarzeń, dla których emiter zarejestrował odbiorniki. Wartości w tablicy to ciągi lub Symbols.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

Zwraca

(string | symbol)[]

Dziedziczone z InternalClient.eventNames

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

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

W przypadku EventEmitterfunkcji s zachowuje się dokładnie tak samo jak wywoływanie .listeners emitera.

Dla EventTargets jest to jedyny sposób, aby uzyskać odbiorniki zdarzeń dla celu 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> | _DOMEventTarget, name: string | symbol): Function[]

Parametry

emitter

EventEmitter<DefaultEventMap> | _DOMEventTarget

name

string | symbol

Zwraca

Function[]

Dziedziczone z InternalClient.getEventListeners

getMaxListeners()

Zwraca bieżącą wartość maksymalnego odbiornika dla wartości, która EventEmitter jest ustawiona domyślnie emitter.setMaxListeners(n) na wartość defaultMaxListeners.

function getMaxListeners(): number

Zwraca

number

Dziedziczone z InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)

Zwraca obecnie ustawioną maksymalną ilość odbiorników.

W przypadku EventEmitterfunkcji s zachowuje się dokładnie tak samo jak wywoływanie .getMaxListeners emitera.

Dla EventTargets jest to jedyny sposób uzyskiwania maksymalnych odbiorników zdarzeń dla docelowego zdarzenia. Jeśli liczba procedur obsługi zdarzeń w pojedynczym obiekcie EventTarget przekracza 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> | _DOMEventTarget): number

Parametry

emitter

EventEmitter<DefaultEventMap> | _DOMEventTarget

Zwraca

number

Dziedziczone z InternalClient.getMaxListeners

getTwin() 

function getTwin(): Promise<Twin>

Zwraca

Promise<Twin>

Dziedziczone z InternalClient.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 emitterobiekcie .

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 zapytań

eventName

string | symbol

Nazwa zdarzenia

Zwraca

number

Dziedziczone z InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

Zwraca liczbę odbiorników nasłuchujących dla zdarzenia o nazwie eventName. Jeśli listener zostanie podana, zwróci liczbę 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łuchiwana

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

ModuleClient

Dziedziczone z InternalClient.off

on(EventEmitter<DefaultEventMap>, string, 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

AsyncIterator Zwraca zdarzenia, które iterują eventName zdarzenia. Zostanie on zgłoszony, jeśli EventEmitter emituje 'error'wartość . Usuwa wszystkie odbiorniki podczas zamykania pętli. Zwracana value przez każdą iterację jest tablicą składającą się z emitowanych argumentów zdarzeń.

Może AbortSignal służyć do anulowania oczekiwania 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());

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

Parametry

emitter

EventEmitter<DefaultEventMap>

eventName

string

Nazwa zdarzenia, dla których jest nasłuchiwana

options

StaticEventEmitterOptions

Zwraca

AsyncIterableIterator<any>

Zdarzenie AsyncIterator , które iteruje eventName zdarzenia emitowane przez emitter

Dziedziczone z InternalClient.on

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

listener Dodaje funkcję na końcu tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane w celu sprawdzenia, czy listener element został już dodany. Wiele wywołań eventName przekazujących tę samą kombinację i listener spowoduje listener dodanie i wywołanie ich wiele razy.

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

Zwraca odwołanie do elementu EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności ich dodawania. Metoda emitter.prependListener() może służyć jako alternatywa do dodawania odbiornika 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): ModuleClient

Parametry

eventName

string | symbol

Nazwa zdarzenia.

listener

(args: any[]) => void

Funkcja wywołania zwrotnego

Zwraca

ModuleClient

Dziedziczone z InternalClient.on

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

Promise Tworzy obiekt, który jest spełniony, gdy EventEmitter emituje podane zdarzenie lub jest odrzucany, jeśli EventEmitter emituje 'error' się podczas oczekiwania. Element Promise zostanie rozpoznany za pomocą tablicy wszystkich argumentów emitowanych do danego zdarzenia.

Ta metoda jest celowo ogólna i współpracuje z interfejsem EventTarget platformy internetowej, który nie ma specjalnych'error' semantyki zdarzeń i nie nasłuchuje 'error' zdarzenia.

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 'error' zdarzenia jest używana tylko wtedy, gdy events.once() jest używana do oczekiwania na inne zdarzenie. Jeśli events.once() jest używany do oczekiwania na samo zdarzenie "error' , 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

Element AbortSignal może służyć do anulowania oczekiwania 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(_DOMEventTarget, string, StaticEventEmitterOptions) 

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

Parametry

emitter

_DOMEventTarget

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 eventName wyzwoleniu 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 elementu EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności ich dodawania. Metoda emitter.prependOnceListener() może służyć jako alternatywa do dodawania odbiornika 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): ModuleClient

Parametry

eventName

string | symbol

Nazwa zdarzenia.

listener

(args: any[]) => void

Funkcja wywołania zwrotnego

Zwraca

ModuleClient

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)

listener Dodaje funkcję na początku tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane w celu sprawdzenia, czy listener element został już dodany. Wiele wywołań eventName przekazujących tę samą kombinację i listener spowoduje listener dodanie i wywołanie ich wiele razy.

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

Zwraca odwołanie do elementu EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

string | symbol

Nazwa zdarzenia.

listener

(args: any[]) => void

Funkcja wywołania zwrotnego

Zwraca

ModuleClient

Dziedziczone z InternalClient.prependListener

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

Dodaje jednorazowąlistener funkcję zdarzenia o nazwie eventName na początku tablicy odbiorników. Przy następnym eventName wyzwoleniu 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 elementu EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

string | symbol

Nazwa zdarzenia.

listener

(args: any[]) => void

Funkcja wywołania zwrotnego

Zwraca

ModuleClient

Dziedziczone z InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName, w tym wszelkie otoki (takie jak utworzone przez .once()program ).

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ślonego eventNameelementu .

Niewłaściwą praktyką jest usunięcie odbiorników dodanych w innym miejscu w kodzie, szczególnie w przypadku EventEmitter utworzenia wystąpienia przez inny składnik lub moduł (np. gniazda lub strumienie plików).

Zwraca odwołanie do elementu EventEmitter, aby można było połączyć wywołania w łańcuch.

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

Parametry

eventName

string | symbol

Zwraca

ModuleClient

Dziedziczone z InternalClient.removeAllListeners

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

Usuwa określony listener element 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() spowoduje usunięcie co najwyżej jednego wystąpienia odbiornika z tablicy odbiornika. Jeśli którykolwiek pojedynczy odbiornik został dodany wiele razy do tablicy odbiornika dla określonego eventNameelementu , 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 removeListener() wywołania lub removeAllListeners()po emitowaniu i przed zakończeniem wykonywania ostatniego odbiornika nie zostaną usunięte zemit() postępu. 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 tej funkcji spowoduje zmianę indeksów pozycji każdego odbiornika zarejestrowanego po usunięciu 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 emitter.listeners() metodę będą musiały zostać ponownie odtworzone.

Jeśli pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie), removeListener() spowoduje usunięcie ostatnio dodanego wystąpienia. W przykładzie odbiornik once('ping') jest usuwany:

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 elementu EventEmitter, aby można było połączyć wywołania w łańcuch.

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

ModuleClient

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 EventEmitterprogram wyświetli ostrzeżenie, jeśli dla określonego zdarzenia zostanie dodanych więcej niż 10 odbiorniki. Jest to przydatne ustawienie domyślne, które pomaga znaleźć przecieki pamięci. Metoda emitter.setMaxListeners() umożliwia zmodyfikowanie limitu dla tego konkretnego EventEmitter wystąpienia. Wartość można ustawić na Infinity (lub 0), aby wskazać nieograniczoną liczbę odbiorników.

Zwraca odwołanie do elementu EventEmitter, aby można było połączyć wywołania w łańcuch.

function setMaxListeners(n: number): ModuleClient

Parametry

n

number

Zwraca

ModuleClient

Dziedziczone z InternalClient.setMaxListeners

setMaxListeners(number, (EventEmitter<DefaultEventMap> | _DOMEventTarget)[]) 

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

Parametry

n

number

Liczba nieujemna. Maksymalna liczba odbiorników na EventTarget zdarzenie.

eventTargets

(EventEmitter<DefaultEventMap> | _DOMEventTarget)[]

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@138