Client class

function close(): Promise<ResultWithIncomingMessage<Disconnected>>

Gibt zurück

Schließt die Verbindung mit einem IoT-Hub.

function close(done?: IncomingMessageCallback<Disconnected>)

Parameter

Erstellt einen IoT Hub-Dienstclient aus der angegebenen Verbindungszeichenfolge mithilfe des Standardtransports (Amqp) oder des im zweiten Argument angegebenen.

static function fromConnectionString(connStr: string, transportCtor?: TransportCtor): Client

Parameter

Gibt zurück

Erstellt einen IoT Hub-Dienstclient aus der angegebenen Freigegebenen Zugriffssignatur mithilfe des Standardtransports (Amqp) oder des im zweiten Argument angegebenen.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor?: TransportCtor): Client

Parameter

Gibt zurück

Erstellt einen IoT Hub-Dienstclient aus dem angegebenen Azure-TokenCredential mithilfe des Standardtransports (Amqp) oder des im zweiten Argument angegebenen.

static function fromTokenCredential(hostName: string, tokenCredential: TokenCredential, transportCtor?: TransportCtor): Client

Parameter

Gibt zurück

function getFeedbackReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

Gibt zurück

Gibt ein AmqpReceiver -Objekt zurück, das Ereignisse ausgibt, wenn neue Feedbacknachrichten vom Client empfangen werden.

function getFeedbackReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Parameter

function getFileNotificationReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

Gibt zurück

Gibt ein AmqpReceiver -Objekt zurück, das Ereignisse ausgibt, wenn neue Dateiuploadbenachrichtigungen vom Client empfangen werden.

function getFileNotificationReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Parameter

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

Parameter

Gibt zurück

Ruft eine Methode auf einem bestimmten Gerät oder Modul auf.

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams, done?: IncomingMessageCallback<any>)

Parameter

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

Parameter

Gibt zurück

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams, done: IncomingMessageCallback<any>)

Parameter

function open(): Promise<ResultWithIncomingMessage<Connected>>

Gibt zurück

Öffnet die Verbindung mit einem IoT-Hub.

function open(done?: IncomingMessageCallback<Connected>)

Parameter

function send(deviceId: string, message: Message | BufferConvertible): Promise<ResultWithIncomingMessage<MessageEnqueued>>

Parameter

Gibt zurück

Sendet eine Nachricht an ein Gerät.

function send(deviceId: string, message: Message | BufferConvertible, done?: IncomingMessageCallback<MessageEnqueued>)

Parameter

Legen Sie die vom Client verwendete Richtlinie fest, um Netzwerkvorgänge erneut auszuführen.

function setRetryPolicy(policy: RetryPolicy)

Parameter

Alias für emitter.on(eventName, listener).

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

Parameter

Gibt zurück

Geerbt von EventEmitter.addListener

Ruft die einzelnen Listener synchron auf, die für das Ereignis mit dem Namen eventNameregistriert wurden, in der Reihenfolge, in der sie registriert wurden, und übergibt die angegebenen Argumente an jedes Ereignis.

Gibt true zurück, wenn das Ereignis Listener hatte, false andernfalls.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

function emit<E>(eventName: string | symbol, args: any[]): boolean

Parameter

Gibt zurück

von EventEmitter.emit geerbt

Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter Listener registriert hat.

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

Gibt zurück

Geerbt von EventEmitter.eventNames

Gibt den aktuellen Maximallistenerwert für die EventEmitter zurück, die entweder durch emitter.setMaxListeners(n) oder standardmäßig auf events.defaultMaxListenersfestgelegt ist.

function getMaxListeners(): number

Gibt zurück

Geerbt von EventEmitter.getMaxListeners

Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen eventNamelauschen. Wenn listener angegeben wird, wird zurückgegeben, wie oft der Listener in der Liste der Listener des Ereignisses gefunden wird.

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

Parameter

Gibt zurück

geerbt von EventEmitter.listenerCount

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventNamezurück.

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

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

Parameter

Gibt zurück

von EventEmitter.listeners geerbt

Alias für emitter.removeListener().

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

Parameter

Gibt zurück

von EventEmitter.off geerbt

Fügt die listener-Funktion am Ende des Listenerarrays für das Ereignis mit dem Namen eventNamehinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die listener bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus eventName übergeben, und listener führen dazu, dass die listener mehrmals hinzugefügt und aufgerufen wird.

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

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die emitter.prependListener()-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Parameter

Gibt zurück

von EventEmitter.on geerbt

Fügt eine einmaligelistener-Funktion für das Ereignis mit dem Namen eventNamehinzu. Wenn eventName das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen.

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

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

Standardmäßig werden Ereignislistener in der Reihenfolge aufgerufen, in der sie hinzugefügt werden. Die emitter.prependOnceListener()-Methode kann als Alternative zum Hinzufügen des Ereignislisteners zum Anfang des Listenersarrays verwendet werden.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Parameter

Gibt zurück

von EventEmitter geerbt.once

Fügt die listener-Funktion dem beginnenden des Listenersarrays für das Ereignis mit dem Namen eventNamehinzu. Es werden keine Überprüfungen vorgenommen, um festzustellen, ob die listener bereits hinzugefügt wurde. Mehrere Aufrufe, die dieselbe Kombination aus eventName übergeben, und listener führen dazu, dass die listener mehrmals hinzugefügt und aufgerufen wird.

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

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

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

Parameter

Gibt zurück

Geerbt von EventEmitter.prependListener

Fügt dem beginnenden des Listenersarrays eine listenereventName Funktion für das Ereignis hinzu, das genannt wird. Wenn eventName das nächste Mal ausgelöst wird, wird dieser Listener entfernt und dann aufgerufen.

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

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

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

Parameter

Gibt zurück

geerbt von EventEmitter.prependOnceListener

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen eventNamezurück, einschließlich aller Wrapper (z. B. von .once()erstellt).

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

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

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

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

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

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

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

Parameter

Gibt zurück

von EventEmitter.rawListeners geerbt

Entfernt alle Listener oder die der angegebenen eventName.

Es empfiehlt sich, Listener zu entfernen, die an anderer Stelle im Code hinzugefügt wurden, insbesondere, wenn die EventEmitter Instanz von einer anderen Komponente oder einem anderen Modul (z. B. Sockets oder Dateistreams) erstellt wurde.

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

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

Parameter

Gibt zurück

geerbt von EventEmitter.removeAllListeners

Entfernt die angegebene listener aus dem Listenerarray für das Ereignis mit dem Namen eventName.

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

removeListener() entfernt höchstens eine Instanz eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für die angegebene eventNamehinzugefügt wurde, muss removeListener() mehrmals aufgerufen werden, um jede Instanz zu entfernen.

Sobald ein Ereignis ausgegeben wird, werden alle listener, die zum Zeitpunkt der Ausstrahlung an sie angefügt sind, in der Reihenfolge aufgerufen. Das bedeutet, dass alle oder removeListener() Aufrufe removeAllListeners()nach der Ausstrahlung und bevor der letzte Hörer die Ausführung beendet hat, sie nicht aus emit() dem laufenden Ablauf entfernen. Nachfolgende Ereignisse verhalten sich wie erwartet.

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

Da Hörer über ein internes Array verwaltet werden, ändert das Aufrufen dieses Hörers die Positionsindizes jedes nach der Entfernung registrierten Listeners. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden. Dies bedeutet jedoch, dass alle Kopien des Listenerarrays, wie sie von der emitter.listeners()-Methode zurückgegeben werden, neu erstellt werden müssen.

Wenn eine einzelne Funktion mehrmals als Handler für ein einzelnes Ereignis (wie im folgenden Beispiel) hinzugefügt wurde, entfernt removeListener() die zuletzt hinzugefügte Instanz. Im Beispiel wird der once('ping') Listener entfernt:

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

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

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

Parameter

Gibt zurück

Geerbt von EventEmitter.removeListener

Standardmäßig druckt EventEmitters eine Warnung, wenn für ein bestimmtes Ereignis mehr als 10 Listener hinzugefügt werden. Dies ist ein nützlicher Standardwert, der hilft, Speicherverluste zu finden. Mit der emitter.setMaxListeners()-Methode kann der Grenzwert für diese spezifische EventEmitter Instanz geändert werden. Der Wert kann auf Infinity (oder 0) festgelegt werden, um eine unbegrenzte Anzahl von Listenern anzugeben.

Gibt einen Verweis auf die EventEmitterzurück, sodass Aufrufe verkettet werden können.

function setMaxListeners(n: number): Client

Parameter

Gibt zurück

Geerbt von EventEmitter.setMaxListeners

Die Methode Symbol.for('nodejs.rejection') wird aufgerufen, wenn eine Versprechensablehnung beim Aussenden eines Ereignisses auftritt und captureRejections auf dem Emitter aktiviert ist. Es ist möglich, anstelle von events.captureRejectionSymbolzu verwendenSymbol.for('nodejs.rejection').

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

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

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

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

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

Parameter

Geerbt von EventEmitter.__@captureRejectionSymbol@90