Share via

DeviceTransport interface

  • Referenz
Paket:
azure-iot-device
Extends

EventEmitter

Methoden

abandon(Message, (err?: Error, results?: MessageAbandoned) => void)
complete(Message, (err?: Error, result?: MessageCompleted) => void)
connect((err?: Error, result?: Connected) => void)
disableC2D((err?: Error) => void)
disableInputMessages((err?: Error) => void)
disableMethods((err?: Error) => void)
disableTwinDesiredPropertiesUpdates((err?: Error) => void)
disconnect((err?: Error, result?: Disconnected) => void)
enableC2D((err?: Error) => void)
enableInputMessages((err?: Error) => void)
enableMethods((err?: Error) => void)
enableTwinDesiredPropertiesUpdates((err?: Error) => void)
getTwin((err?: Error, twin?: TwinProperties) => void)
on("connected", () => void)
on("disconnect", (err?: Error) => void)
on("error", (err: Error) => void)
on("inputMessage", (inputName: string, msg: Message) => void)
on("message", (msg: Message) => void)
on("twinDesiredPropertiesUpdate", (desiredProps: any) => void)
onDeviceMethod(string, (request: MethodMessage, response: DeviceMethodResponse) => void)
reject(Message, (err?: Error, results?: MessageRejected) => void)
sendEvent(Message, (err?: Error, result?: MessageEnqueued) => void)
sendEventBatch(Message[], (err?: Error, result?: MessageEnqueued) => void)
sendMethodResponse(DeviceMethodResponse, (err?: Error, result?: any) => void)
sendOutputEvent(string, Message, (err?: Error, result?: MessageEnqueued) => void)
sendOutputEventBatch(string, Message[], (err?: Error, result?: MessageEnqueued) => void)
setOptions(DeviceClientOptions, (err?: Error, result?: TransportConfigured) => void)
updateSharedAccessSignature(string, (err?: Error, result?: SharedAccessSignatureUpdated) => void)
updateTwinReportedProperties(any, (err?: Error) => void)

Geerbte Methoden

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

Alias für emitter.on(eventName, listener).
emit<K>(string | symbol, AnyRest)

Ruft synchron alle Listener auf, die für das Ereignis namens eventNameregistriert sind, in der Reihenfolge, in der sie registriert wurden, und übergibt die angegebenen Argumente an jeden.

Gibt zurück true , wenn das Ereignis über Listener verfügt, 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
eventNames()

Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter über registrierte Listener verfügt. 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) ]
getMaxListeners()

Gibt den aktuellen maximalen Listenerwert für den zurück, der EventEmitter entweder von emitter.setMaxListeners(n) oder standardmäßig auf defaultMaxListenersfestgelegt ist.
listenerCount<K>(string | symbol, Function)

Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen eventNamelauschen. Wenn listener angegeben, wird zurückgegeben, wie oft der Listener in der Liste der Listener des Ereignisses gefunden wird.
listeners<K>(string | symbol)

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen zurück 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 für emitter.removeListener().
once<K>(string | symbol, (args: any[]) => void)

Fügt eine einmaligelistener Funktion für das Ereignis mit dem Namen hinzu eventName. Wenn das nächste Mal eventName 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 zurück EventEmitter, damit 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 verwendet werden, um den Ereignislistener am Anfang des Listenerarrays hinzuzufügen.

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

Fügt die listener Funktion am Anfang des Listenerarrays für das Ereignis mit dem Namen hinzu eventName. Es werden keine Überprüfungen durchgeführt, um festzustellen, ob der listener bereits hinzugefügt wurde. Mehrere Aufrufe, die die gleiche Kombination von eventName und listener übergeben, führen dazu, dass der listener mehrmals hinzugefügt und aufgerufen wird.

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

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Fügt eine einmaligelistener Funktion für das Ereignis mit dem Namen eventName am Anfang des Listenerarrays hinzu. Wenn das nächste Mal eventName 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 zurück EventEmitter, damit Aufrufe verkettet werden können.
rawListeners<K>(string | symbol)

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

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');
removeAllListeners(string | symbol)

Entfernt alle Listener oder die des angegebenen eventName.

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

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.
removeListener<K>(string | symbol, (args: any[]) => void)

Entfernt das 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 einen instance eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für den angegebenen eventNamehinzugefügt wurde, removeListener() muss mehrmals aufgerufen werden, um jeden instance zu entfernen.

Sobald ein Ereignis ausgegeben wurde, werden alle Listener, die zum Zeitpunkt der Ausgabe an das Ereignis angefügt sind, in der Reihenfolge aufgerufen. Dies bedeutet, dass Aufrufe removeListener()oderremoveAllListeners() nach dem Ausgeben und vor Abschluss der ausführung des letzten Listeners sie nicht aus deremit() laufenden Ausführung 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 Listener mithilfe eines internen Arrays verwaltet werden, werden die Positionsindizes aller Listener geändert, die nach dem Entfernen des Listeners registriert wurden. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden, 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 hinzugefügt wurde (wie im folgenden Beispiel), removeListener() wird die zuletzt hinzugefügte instance entfernt. 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 zurück EventEmitter, damit Aufrufe verkettet werden können.
setMaxListeners(number)

Standardmäßig EventEmittergibt s eine Warnung aus, wenn für ein bestimmtes Ereignis mehr als 10 Listener hinzugefügt werden. Dies ist ein nützlicher Standard, mit dem Speicherverluste gefunden werden können. Mit emitter.setMaxListeners() der -Methode kann der Grenzwert für diese spezifische EventEmitter instance geändert werden. Der Wert kann auf Infinity (oder 0) festgelegt werden, um eine unbegrenzte Anzahl von Listenern anzugeben.

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Details zur Methode

abandon(Message, (err?: Error, results?: MessageAbandoned) => void) 

function abandon(message: Message, done: (err?: Error, results?: MessageAbandoned) => void)

Parameter

message
Message
done

(err?: Error, results?: MessageAbandoned) => void

complete(Message, (err?: Error, result?: MessageCompleted) => void) 

function complete(message: Message, done: (err?: Error, result?: MessageCompleted) => void)

Parameter

message
Message
done

(err?: Error, result?: MessageCompleted) => void

connect((err?: Error, result?: Connected) => void) 

function connect(done: (err?: Error, result?: Connected) => void)

Parameter

done

(err?: Error, result?: Connected) => void

disableC2D((err?: Error) => void) 

function disableC2D(callback: (err?: Error) => void)

Parameter

callback

(err?: Error) => void

disableInputMessages((err?: Error) => void) 

function disableInputMessages(callback: (err?: Error) => void)

Parameter

callback

(err?: Error) => void

disableMethods((err?: Error) => void) 

function disableMethods(callback: (err?: Error) => void)

Parameter

callback

(err?: Error) => void

disableTwinDesiredPropertiesUpdates((err?: Error) => void) 

function disableTwinDesiredPropertiesUpdates(callback: (err?: Error) => void)

Parameter

callback

(err?: Error) => void

disconnect((err?: Error, result?: Disconnected) => void) 

function disconnect(done: (err?: Error, result?: Disconnected) => void)

Parameter

done

(err?: Error, result?: Disconnected) => void

enableC2D((err?: Error) => void) 

function enableC2D(callback: (err?: Error) => void)

Parameter

callback

(err?: Error) => void

enableInputMessages((err?: Error) => void) 

function enableInputMessages(callback: (err?: Error) => void)

Parameter

callback

(err?: Error) => void

enableMethods((err?: Error) => void) 

function enableMethods(callback: (err?: Error) => void)

Parameter

callback

(err?: Error) => void

enableTwinDesiredPropertiesUpdates((err?: Error) => void) 

function enableTwinDesiredPropertiesUpdates(callback: (err?: Error) => void)

Parameter

callback

(err?: Error) => void

getTwin((err?: Error, twin?: TwinProperties) => void) 

function getTwin(callback: (err?: Error, twin?: TwinProperties) => void)

Parameter

callback

(err?: Error, twin?: TwinProperties) => void

on("connected", () => void) 

function on(type: "connected", func: () => void): DeviceTransport

Parameter

type

"connected"

func

() => void

Gibt zurück

DeviceTransport

on("disconnect", (err?: Error) => void) 

function on(type: "disconnect", func: (err?: Error) => void): DeviceTransport

Parameter

type

"disconnect"

func

(err?: Error) => void

Gibt zurück

DeviceTransport

on("error", (err: Error) => void) 

function on(type: "error", func: (err: Error) => void): DeviceTransport

Parameter

type

"error"

func

(err: Error) => void

Gibt zurück

DeviceTransport

on("inputMessage", (inputName: string, msg: Message) => void) 

function on(type: "inputMessage", func: (inputName: string, msg: Message) => void): DeviceTransport

Parameter

type

"inputMessage"

func

(inputName: string, msg: Message) => void

Gibt zurück

DeviceTransport

on("message", (msg: Message) => void) 

function on(type: "message", func: (msg: Message) => void): DeviceTransport

Parameter

type

"message"

func

(msg: Message) => void

Gibt zurück

DeviceTransport

on("twinDesiredPropertiesUpdate", (desiredProps: any) => void) 

function on(type: "twinDesiredPropertiesUpdate", func: (desiredProps: any) => void): DeviceTransport

Parameter

type

"twinDesiredPropertiesUpdate"

func

(desiredProps: any) => void

Gibt zurück

DeviceTransport

onDeviceMethod(string, (request: MethodMessage, response: DeviceMethodResponse) => void) 

function onDeviceMethod(methodName: string, methodCallback: (request: MethodMessage, response: DeviceMethodResponse) => void)

Parameter

methodName

string

methodCallback

(request: MethodMessage, response: DeviceMethodResponse) => void

reject(Message, (err?: Error, results?: MessageRejected) => void) 

function reject(message: Message, done: (err?: Error, results?: MessageRejected) => void)

Parameter

message
Message
done

(err?: Error, results?: MessageRejected) => void

sendEvent(Message, (err?: Error, result?: MessageEnqueued) => void) 

function sendEvent(message: Message, done: (err?: Error, result?: MessageEnqueued) => void)

Parameter

message
Message
done

(err?: Error, result?: MessageEnqueued) => void

sendEventBatch(Message[], (err?: Error, result?: MessageEnqueued) => void) 

function sendEventBatch(messages: Message[], done: (err?: Error, result?: MessageEnqueued) => void)

Parameter

messages

Message[]

done

(err?: Error, result?: MessageEnqueued) => void

sendMethodResponse(DeviceMethodResponse, (err?: Error, result?: any) => void) 

function sendMethodResponse(response: DeviceMethodResponse, done?: (err?: Error, result?: any) => void)

Parameter

response
DeviceMethodResponse
done

(err?: Error, result?: any) => void

sendOutputEvent(string, Message, (err?: Error, result?: MessageEnqueued) => void) 

function sendOutputEvent(outputName: string, message: Message, done: (err?: Error, result?: MessageEnqueued) => void)

Parameter

outputName

string

message
Message
done

(err?: Error, result?: MessageEnqueued) => void

sendOutputEventBatch(string, Message[], (err?: Error, result?: MessageEnqueued) => void) 

function sendOutputEventBatch(outputName: string, messages: Message[], done: (err?: Error, result?: MessageEnqueued) => void)

Parameter

outputName

string

messages

Message[]

done

(err?: Error, result?: MessageEnqueued) => void

setOptions(DeviceClientOptions, (err?: Error, result?: TransportConfigured) => void) 

function setOptions(options: DeviceClientOptions, done: (err?: Error, result?: TransportConfigured) => void)

Parameter

options
DeviceClientOptions
done

(err?: Error, result?: TransportConfigured) => void

updateSharedAccessSignature(string, (err?: Error, result?: SharedAccessSignatureUpdated) => void) 

function updateSharedAccessSignature(sharedAccessSignature: string, done: (err?: Error, result?: SharedAccessSignatureUpdated) => void)

Parameter

sharedAccessSignature

string

done

(err?: Error, result?: SharedAccessSignatureUpdated) => void

updateTwinReportedProperties(any, (err?: Error) => void) 

function updateTwinReportedProperties(patch: any, callback: (err?: Error) => void)

Parameter

patch

any

callback

(err?: Error) => void

Details zur geerbten Methode

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

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

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

Parameter

eventName

string | symbol

listener

(args: any[]) => void

Gibt zurück

DeviceTransport

Geerbt von EventEmitter.addListener

emit<K>(string | symbol, AnyRest)

Ruft synchron alle Listener auf, die für das Ereignis namens eventNameregistriert sind, in der Reihenfolge, in der sie registriert wurden, und übergibt die angegebenen Argumente an jeden.

Gibt zurück true , wenn das Ereignis über Listener verfügt, 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

eventName

string | symbol

args

AnyRest

Gibt zurück

boolean

Geerbt von EventEmitter.emit

eventNames()

Gibt ein Array zurück, das die Ereignisse auflistet, für die der Emitter über registrierte Listener verfügt. 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

(string | symbol)[]

Geerbt von EventEmitter.eventNames

getMaxListeners()

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

function getMaxListeners(): number

Gibt zurück

number

Geerbt von EventEmitter.getMaxListeners

listenerCount<K>(string | symbol, Function)

Gibt die Anzahl der Listener zurück, die auf das Ereignis mit dem Namen eventNamelauschen. Wenn listener angegeben, 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

eventName

string | symbol

Der Name des Ereignisses, auf das lauscht wird

listener

Function

Die Ereignishandlerfunktion

Gibt zurück

number

Geerbt von EventEmitter.listenerCount

listeners<K>(string | symbol)

Gibt eine Kopie des Arrays von Listenern für das Ereignis mit dem Namen zurück 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[]

Parameter

eventName

string | symbol

Gibt zurück

Function[]

Geerbt von EventEmitter.listeners

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

Alias für emitter.removeListener().

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

Parameter

eventName

string | symbol

listener

(args: any[]) => void

Gibt zurück

DeviceTransport

Geerbt von EventEmitter.off

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

Fügt eine einmaligelistener Funktion für das Ereignis mit dem Namen hinzu eventName. Wenn das nächste Mal eventName 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 zurück EventEmitter, damit 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 verwendet werden, um den Ereignislistener am Anfang des Listenerarrays hinzuzufügen.

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

Parameter

eventName

string | symbol

Der Name des Ereignisses.

listener

(args: any[]) => void

Die Rückruffunktion

Gibt zurück

DeviceTransport

Geerbt von EventEmitter.once

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

Fügt die listener Funktion am Anfang des Listenerarrays für das Ereignis mit dem Namen hinzu eventName. Es werden keine Überprüfungen durchgeführt, um festzustellen, ob der listener bereits hinzugefügt wurde. Mehrere Aufrufe, die die gleiche Kombination von eventName und listener übergeben, führen dazu, dass der listener mehrmals hinzugefügt und aufgerufen wird.

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

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.

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

Parameter

eventName

string | symbol

Der Name des Ereignisses.

listener

(args: any[]) => void

Die Rückruffunktion

Gibt zurück

DeviceTransport

Geerbt von EventEmitter.prependListener

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

Fügt eine einmaligelistener Funktion für das Ereignis mit dem Namen eventName am Anfang des Listenerarrays hinzu. Wenn das nächste Mal eventName 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 zurück EventEmitter, damit Aufrufe verkettet werden können.

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

Parameter

eventName

string | symbol

Der Name des Ereignisses.

listener

(args: any[]) => void

Die Rückruffunktion

Gibt zurück

DeviceTransport

Geerbt von EventEmitter.prependOnceListener

rawListeners<K>(string | symbol)

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

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

eventName

string | symbol

Gibt zurück

Function[]

Geerbt von EventEmitter.rawListeners

removeAllListeners(string | symbol)

Entfernt alle Listener oder die des angegebenen eventName.

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

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.

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

Parameter

eventName

string | symbol

Gibt zurück

DeviceTransport

Geerbt von EventEmitter.removeAllListeners

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

Entfernt das 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 einen instance eines Listeners aus dem Listenerarray. Wenn ein einzelner Listener mehrmals zum Listenerarray für den angegebenen eventNamehinzugefügt wurde, removeListener() muss mehrmals aufgerufen werden, um jeden instance zu entfernen.

Sobald ein Ereignis ausgegeben wurde, werden alle Listener, die zum Zeitpunkt der Ausgabe an das Ereignis angefügt sind, in der Reihenfolge aufgerufen. Dies bedeutet, dass Aufrufe removeListener()oderremoveAllListeners() nach dem Ausgeben und vor Abschluss der ausführung des letzten Listeners sie nicht aus deremit() laufenden Ausführung 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 Listener mithilfe eines internen Arrays verwaltet werden, werden die Positionsindizes aller Listener geändert, die nach dem Entfernen des Listeners registriert wurden. Dies wirkt sich nicht auf die Reihenfolge aus, in der Listener aufgerufen werden, 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 hinzugefügt wurde (wie im folgenden Beispiel), removeListener() wird die zuletzt hinzugefügte instance entfernt. 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 zurück EventEmitter, damit Aufrufe verkettet werden können.

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

Parameter

eventName

string | symbol

listener

(args: any[]) => void

Gibt zurück

DeviceTransport

Geerbt von EventEmitter.removeListener

setMaxListeners(number)

Standardmäßig EventEmittergibt s eine Warnung aus, wenn für ein bestimmtes Ereignis mehr als 10 Listener hinzugefügt werden. Dies ist ein nützlicher Standard, mit dem Speicherverluste gefunden werden können. Mit emitter.setMaxListeners() der -Methode kann der Grenzwert für diese spezifische EventEmitter instance geändert werden. Der Wert kann auf Infinity (oder 0) festgelegt werden, um eine unbegrenzte Anzahl von Listenern anzugeben.

Gibt einen Verweis auf zurück EventEmitter, damit Aufrufe verkettet werden können.

function setMaxListeners(n: number): DeviceTransport

Parameter

n

number

Gibt zurück

DeviceTransport

Geerbt von EventEmitter.setMaxListeners

[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest) 

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

Parameter

error

Error

event

string | symbol

args

AnyRest

Geerbt von EventEmitter.__@captureRejectionSymbol@138