Client class

new Client(transport: DeviceTransport, connStr?: string, blobUploadClient?: BlobUploadClient, fileUploadApi?: FileUploadInterface)

Parameter

Wert: boolesch

Ändere die Standardoption captureRejections bei allen neuen EventEmitter Objekten.

static captureRejections: boolean

Eigenschaftswert

Geerbt von InternalClient.captureAblehnungen

Wert: Symbol.for('nodejs.rejection')

Sieh dir an, wie man eine benutzerdefinierte rejection handlerFormulierung schreibt.

static captureRejectionSymbol: typeof captureRejectionSymbol

Eigenschaftswert

Geerbt von InternalClient.captureAblehnungssymbol

Standardmäßig können für ein einzelnes Event ein Maximum an 10 Zuhörern registriert werden. Dieses Limit kann mit der Methode emitter.setMaxListeners(n) für einzelne EventEmitter Instanzen angepasst werden. Um den Standard für alleEventEmitter Instanzen zu ändern, kann die Eigenschaft events.defaultMaxListeners verwendet werden. Wenn dieser Wert keine positive Zahl ist, wird a RangeError geworfen.

Seien Sie vorsichtig bei der events.defaultMaxListeners Einstellung, da die Änderung alleEventEmitter Instanzen betrifft, einschließlich derjenigen, die vor der Änderung erstellt wurden. Allerdings hat das Anrufen emitter.setMaxListeners(n) immer noch Vorrang vor events.defaultMaxListeners.

Das ist keine feste Grenze. Die Instanz EventEmitter erlaubt es, weitere Zuhörer hinzuzufügen, gibt aber eine Trace-Warnung an stderr aus, die darauf hinweist, dass ein "mögliches EventEmitter-Speicherleck" erkannt wurde. Für jede einzelne EventEmitterMethode können die emitter.getMaxListeners() und-Methoden emitter.setMaxListeners() verwendet werden, um diese Warnung vorübergehend zu vermeiden:

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

Das Kommandozeilen-Flag --trace-warnings kann verwendet werden, um die Stack-Trace für solche Warnungen anzuzeigen.

Die ausgesendete Warnung kann mit process.on('warning') und besitzt die zusätzlichen emitter, type, und count Eigenschaften besitzen, die sich auf die Instanz des Ereignisemitters, den Namen des Ereignisses und die Anzahl der angeschlossenen Zuhörer beziehen. Seine Eigenschaft name ist gesetzt auf 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Eigenschaftswert

Geerbt von InternalClient.defaultMaxListeners

Dieses Symbol soll verwendet werden, um einen Zuhörer zu installieren, der nur Ereignisse überwacht 'error' . Zuhörer, die mit diesem Symbol installiert sind, werden aufgerufen, bevor die regulären 'error' Zuhörer aufgerufen werden.

Die Installation eines Listeners mit diesem Symbol ändert das Verhalten nicht, sobald ein 'error' Ereignis ausgesendet wird. Daher stürzt der Prozess trotzdem ab, wenn kein regulärer 'error' Listener installiert ist.

static errorMonitor: typeof errorMonitor

Eigenschaftswert

Geerbt von InternalClient.errorMonitor

function close(): Promise<Disconnected>

Gibt zurück

Schließt die Transportverbindung und zerstört die Clientressourcen.

Hinweis: Nach dem Aufrufen dieser Methode kann das Client-Objekt nicht wiederverwendet werden.

function close(closeCallback?: Callback<Disconnected>)

Parameter

Erstellt einen IoT Hub-Geräteclient aus der angegebenen Authentifizierungsmethode und verwendet den angegebenen Transporttyp.

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

Parameter

Gibt zurück

Erstellt einen IoT Hub-Geräteclient aus der angegebenen Verbindungszeichenfolge mithilfe des angegebenen Transporttyps.

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

Parameter

Gibt zurück

Erstellt mithilfe des angegebenen Transporttyps einen IoT Hub-Geräteclient aus der angegebenen Signatur für den freigegebenen Zugriff.

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

Parameter

Gibt zurück

function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>

Parameter

Gibt zurück

Die getBlobSharedAccessSignature ruft das verknüpfte Speicherkonto-SAS-Token vom IoT Hub ab.

function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)

Parameter

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string): Promise<void>

Parameter

Gibt zurück

Die notifyBlobUploadStatus-Methode sendet IoT Hub das Ergebnis eines BLOB-Uploads.

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)

Parameter

Registriert einen Rückruf für eine Methode mit dem Namen methodName.

function onDeviceMethod(methodName: string, callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Parameter

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

Parameter

Gibt zurück

Übergibt Optionen an das Client-Objekt, das zum Konfigurieren des Transports verwendet werden kann.

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

Parameter

function uploadToBlob(blobName: string, stream: Stream, streamLength: number): Promise<void>

Parameter

Gibt zurück

Die uploadToBlob-Methode lädt einen Datenstrom in ein BLOB hoch.

function uploadToBlob(blobName: string, stream: Stream, streamLength: number, callback: ErrorCallback)

Parameter

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

Parameter

Gibt zurück

Geerbt von InternalClient.abandon

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

Parameter

Geerbt von InternalClient.abandon

Hört sich einmal das abort Ereignis auf dem bereitgestellten signalBildschirm an.

Das Abhören des abort Ereignisses bei Abbruchsignalen ist unsicher und kann zu Ressourcenlecks führen, da ein anderer Dritter mit dem Signal anrufen e.stopImmediatePropagation()kann. Leider kann das Node.js nicht ändern, da es gegen den Webstandard verstoßen würde. Außerdem macht die ursprüngliche API es einfach, Hörer zu vergessen.

Diese API ermöglicht die sichere Verwendung AbortSignalvon s-in-Node.js-APIs, indem diese beiden Probleme gelöst werden, indem sie dem Ereignis zuhört, sodass stopImmediatePropagation der Listener nicht am Ausführen hindert.

Gibt ein Einweg-Paket zurück, damit es leichter abgemeldet werden kann.

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

Parameter

Gibt zurück

Wegwerfer, der den Zuhörer abort entfernt.

Geerbt von InternalClient.addAbortListener

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

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

Parameter

Gibt zurück

Geerbt von InternalClient.addListener

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

Parameter

Gibt zurück

Geerbt von InternalClient.complete

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

Parameter

Geerbt von InternalClient.complete

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<K>(eventName: string | symbol, args: AnyRest): boolean

Parameter

Gibt zurück

von InternalClient.emit geerbt

Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter Listener registriert hat. Die Werte im Array sind Zeichenfolgen oder 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)[]

Gibt zurück

Geerbt von InternalClient.eventNames

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

Für EventEmitters verhält sich dies genau wie das Anrufen .listeners des Emitters.

Für EventTargets ist dies der einzige Weg, die Ereignis-Hörer für das Ereignisziel zu erhalten. Dies ist nützlich für Debugging- und Diagnosezwecke.

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 | EventTarget, name: string | symbol): Function[]

Parameter

Gibt zurück

Übernommen von InternalClient.getEventListeners

Gibt den aktuellen maximalen Listenerwert zurück EventEmitter , der entweder von emitter.setMaxListeners(n)EventEmitter.defaultMaxListeners gesetzt oder standardmäßig gesetzt ist.

function getMaxListeners(): number

Gibt zurück

Geerbt von InternalClient.getMaxListeners

Gibt die derzeit festgelegte maximale Hörerzahl zurück.

Für EventEmitters verhält sich dies genau wie das Anrufen .getMaxListeners des Emitters.

Für EventTargets ist dies der einzige Weg, die maximalen Ereignis-Listener für das Ereignisziel zu erreichen. Wenn die Anzahl der Event-Handler auf einem einzelnen EventTarget das maximale Set übersteigt, druckt das EventTarget eine Warnung aus.

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 | EventTarget): number

Parameter

Gibt zurück

Geerbt von InternalClient.getMaxListeners

function getTwin(): Promise<Twin>

Gibt zurück

Von InternalClient.getTwin geerbt

function getTwin(done: Callback<Twin>)

Parameter

Von InternalClient.getTwin geerbt

Eine Klassenmethode, die die Anzahl der Zuhörer für das gegebene eventName registrierte auf dem gegebenen emitterzurückgibt.

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, eventName: string | symbol): number

Parameter

Gibt zurück

geerbt von InternalClient.listenerCount

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<K>(eventName: string | symbol, listener?: Function): number

Parameter

Gibt zurück

geerbt von InternalClient.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<K>(eventName: string | symbol): Function[]

Parameter

Gibt zurück

von InternalClient.listeners geerbt

Alias für emitter.removeListener().

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

Parameter

Gibt zurück

von InternalClient.off geerbt

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

Kehrt zurück und AsyncIterator iteriert eventName Ereignisse. Es wird geworfen, wenn der Sender EventEmitter aussendet 'error'. Beim Beenden der Schleife werden alle Zuhörer entfernt. Das von jeder Iteration zurückgegebene Array value ist ein Array, das aus den emittierten Ereignisargumenten besteht.

An AbortSignal kann verwendet werden, um Wartezeiten auf Veranstaltungen abzubrechen:

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

Verwenden Sie die Option, close um ein Array von Ereignisnamen anzugeben, die die Iteration beenden:

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, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[]>

Parameter

Gibt zurück

An AsyncIterator , der Ereignisse iteriert eventName , die von den emitter

von InternalClient.on geerbt

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[]>

Parameter

Gibt zurück

von InternalClient.on 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<K>(eventName: string | symbol, listener: (args: any[]) => void): this

Parameter

Gibt zurück

von InternalClient.on geerbt

Erzeugt ein Promise Ereignis, das erfüllt wird, wenn das EventEmitter gegebene Ereignis ausgesendet wird, oder das abgelehnt wird, wenn das Ereignis während des EventEmitter Wartens ausgesendet 'error' wird. Sie Promise lösen sich mit einem Array aller Argumente, die auf das gegebene Ereignis eingebracht wurden.

Diese Methode ist absichtlich generisch und funktioniert mit der Webplattform EventTarget-Oberfläche , die keine Spezialereignis-Semantik'error' hat und das Ereignis 'error' nicht anerkennt.

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

Die besondere Steuerung des Ereignisses 'error' wird nur verwendet, wenn events.once() es zum Warten auf ein anderes Ereignis genutzt wird. Wenn events.once() verwendet wird, um auf das 'error' -Ereignis selbst zu warten, wird es wie jede andere Art von Ereignis ohne besondere Behandlung behandelt:

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

An kann verwendet werden, um das Warten AbortSignal auf die Veranstaltung abzusagen:

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, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>

Parameter

Gibt zurück

von InternalClient.once geerbt

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

Parameter

Gibt zurück

von InternalClient.once 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<K>(eventName: string | symbol, listener: (args: any[]) => void): this

Parameter

Gibt zurück

von InternalClient.once geerbt

function open(): Promise<Connected>

Gibt zurück

Von InternalClient.open geerbt

function open(openCallback: Callback<Connected>)

Parameter

Von InternalClient.open geerbt

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

Parameter

Gibt zurück

geerbt von InternalClient.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<K>(eventName: string | symbol, listener: (args: any[]) => void): this

Parameter

Gibt zurück

geerbt von InternalClient.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<K>(eventName: string | symbol): Function[]

Parameter

Gibt zurück

von InternalClient.rawListeners geerbt

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

Parameter

Gibt zurück

von InternalClient.reject geerbt

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

Parameter

von InternalClient.reject 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(eventName?: string | symbol): this

Parameter

Gibt zurück

geerbt von InternalClient.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. Dies bedeutet, dass alle removeListener() oder removeAllListeners() Aufrufe nach Senden und , bevor die letzte Listenerausführung beendet wird, diese nicht ausemit() entfernt. 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 Listener mithilfe eines internen Arrays verwaltet werden, ändert das Aufrufen die Positionsindizes aller listener, die registriert sind, nachdem der Listener entfernt wurde. 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<K>(eventName: string | symbol, listener: (args: any[]) => void): this

Parameter

Gibt zurück

Geerbt von InternalClient.removeListener

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

Parameter

Gibt zurück

geerbt von InternalClient.sendEvent

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

Parameter

geerbt von InternalClient.sendEvent

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

Parameter

Gibt zurück

von InternalClient.sendEventBatch geerbt

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

Parameter

von InternalClient.sendEventBatch geerbt

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

Parameter

Gibt zurück

Geerbt von InternalClient.setMaxListeners

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

Parameter

Geerbt von InternalClient.setMaxListeners

Legt die Vom Client verwendete Wiederholungsrichtlinie für alle Vorgänge fest. Der Standardwert ist ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parameter

Geerbt von InternalClient.setRetryPolicy

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

Parameter

Gibt zurück

Geerbt von InternalClient.setTransportOptions

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

Parameter

Geerbt von InternalClient.setTransportOptions

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

Parameter

Geerbt von InternalClient.updateSharedAccessSignature

function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)

Parameter

Geerbt von Internem Klienten. [fangenAblehnungssymbol]