Condividi tramite

DeviceTransport interface

  • Riferimento
Pacchetto:
azure-iot-device
Extends

EventEmitter

Metodi

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)

Metodi ereditati

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

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

Chiama in modo sincrono ognuno dei listener registrati per l'evento denominato eventName, nell'ordine in cui sono stati registrati, passando gli argomenti forniti a ognuno.

Restituisce true se l'evento aveva listener, false in caso contrario.

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

Restituisce una matrice che elenca gli eventi per i quali l'emittente ha registrato listener. I valori della matrice sono stringhe o 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()

Restituisce il valore del listener massimo corrente per il EventEmitter quale è impostato per o per impostazione emitter.setMaxListeners(n) predefinita su defaultMaxListeners.
listenerCount<K>(string | symbol, Function)

Restituisce il numero di listener in ascolto dell'evento denominato eventName. Se listener viene specificato, restituirà il numero di volte in cui viene trovato il listener nell'elenco dei listener dell'evento.
listeners<K>(string | symbol)

Restituisce una copia della matrice di listener per l'evento denominato 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 per emitter.removeListener().
once<K>(string | symbol, (args: any[]) => void)

Aggiunge una funzione monousolistener per l'evento denominato eventName. Al successivo eventName attivazione, questo listener viene rimosso e quindi richiamato.

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

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.

Per impostazione predefinita, i listener di eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il emitter.prependOnceListener() metodo può essere usato come alternativa per aggiungere il listener di eventi all'inizio della matrice listener.

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)

Aggiunge la listener funzione all'inizio della matrice listener per l'evento denominato eventName. Non vengono effettuati controlli per verificare se è già stato aggiunto .listener Più chiamate che passano la stessa combinazione di eventName e listener comportano l'aggiunta listener e la chiamata, più volte.

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

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Aggiunge una funzione monousolistener per l'evento denominato eventNameall'inizio della matrice listener. La volta eventName successiva viene attivata, questo listener viene rimosso e quindi richiamato.

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

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.
rawListeners<K>(string | symbol)

Restituisce una copia della matrice di listener per l'evento denominato eventName, inclusi eventuali wrapper, ad esempio quelli creati da .once().

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

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

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

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

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

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

Rimuove tutti i listener o quelli dell'oggetto specificato eventName.

È consigliabile rimuovere listener aggiunti altrove nel codice, in particolare quando l'istanza EventEmitter è stata creata da un altro componente o modulo ,ad esempio socket o flussi di file.

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.
removeListener<K>(string | symbol, (args: any[]) => void)

Rimuove l'oggetto specificato listener dalla matrice del listener per l'evento denominato eventName.

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

removeListener() rimuoverà al massimo un'istanza di un listener dalla matrice del listener. Se un listener singolo è stato aggiunto più volte alla matrice del listener per l'oggetto specificato eventName, removeListener() è necessario chiamare più volte per rimuovere ogni istanza.

Una volta generato un evento, tutti i listener collegati al listener al momento dell'emissione vengono chiamati in ordine. Ciò implica che qualsiasi removeListener() chiamata o removeAllListeners()dopo l'emissione e prima che l'ultimo listener finisca l'esecuzione non li rimuoverà daemit() in corso. Gli eventi successivi si comportano come previsto.

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

Poiché i listener vengono gestiti tramite una matrice interna, la chiamata di questa operazione modificherà gli indici di posizione di qualsiasi listener registrato dopo la rimozione del listener. Ciò non influirà sull'ordine in cui vengono chiamati i listener, ma significa che tutte le copie della matrice del listener restituite dal emitter.listeners() metodo dovranno essere ricreate.

Quando una singola funzione è stata aggiunta più volte come gestore per un singolo evento (come nell'esempio seguente), removeListener() rimuoverà l'istanza aggiunta più di recente. Nell'esempio il once('ping') listener viene rimosso:

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

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.
setMaxListeners(number)

Per impostazione predefinita EventEmitter, verrà visualizzato un avviso se vengono aggiunti più 10 listener per un determinato evento. Si tratta di un valore predefinito utile che consente di trovare perdite di memoria. Il emitter.setMaxListeners() metodo consente di modificare il limite per questa istanza specifica EventEmitter . Il valore può essere impostato su Infinity (o 0) per indicare un numero illimitato di listener.

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Dettagli metodo

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

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

Parametri

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)

Parametri

message
Message
done

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

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

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

Parametri

done

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

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

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

Parametri

callback

(err?: Error) => void

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

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

Parametri

callback

(err?: Error) => void

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

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

Parametri

callback

(err?: Error) => void

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

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

Parametri

callback

(err?: Error) => void

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

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

Parametri

done

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

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

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

Parametri

callback

(err?: Error) => void

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

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

Parametri

callback

(err?: Error) => void

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

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

Parametri

callback

(err?: Error) => void

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

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

Parametri

callback

(err?: Error) => void

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

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

Parametri

callback

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

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

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

Parametri

type

"connected"

func

() => void

Restituisce

DeviceTransport

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

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

Parametri

type

"disconnect"

func

(err?: Error) => void

Restituisce

DeviceTransport

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

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

Parametri

type

"error"

func

(err: Error) => void

Restituisce

DeviceTransport

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

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

Parametri

type

"inputMessage"

func

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

Restituisce

DeviceTransport

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

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

Parametri

type

"message"

func

(msg: Message) => void

Restituisce

DeviceTransport

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

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

Parametri

type

"twinDesiredPropertiesUpdate"

func

(desiredProps: any) => void

Restituisce

DeviceTransport

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

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

Parametri

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)

Parametri

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)

Parametri

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)

Parametri

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)

Parametri

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)

Parametri

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)

Parametri

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)

Parametri

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)

Parametri

sharedAccessSignature

string

done

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

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

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

Parametri

patch

any

callback

(err?: Error) => void

Dettagli dei metodi ereditati

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

Alias per emitter.on(eventName, listener).

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

DeviceTransport

Ereditato da EventEmitter.addListener

emit<K>(string | symbol, AnyRest)

Chiama in modo sincrono ognuno dei listener registrati per l'evento denominato eventName, nell'ordine in cui sono stati registrati, passando gli argomenti forniti a ognuno.

Restituisce true se l'evento aveva listener, false in caso contrario.

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

Parametri

eventName

string | symbol

args

AnyRest

Restituisce

boolean

Ereditato da EventEmitter.emit

eventNames()

Restituisce una matrice che elenca gli eventi per i quali l'emittente ha registrato listener. I valori della matrice sono stringhe o 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)[]

Restituisce

(string | symbol)[]

Ereditato da EventEmitter.eventNames

getMaxListeners()

Restituisce il valore del listener massimo corrente per il EventEmitter quale è impostato per o per impostazione emitter.setMaxListeners(n) predefinita su defaultMaxListeners.

function getMaxListeners(): number

Restituisce

number

Ereditato da EventEmitter.getMaxListeners

listenerCount<K>(string | symbol, Function)

Restituisce il numero di listener in ascolto dell'evento denominato eventName. Se listener viene specificato, restituirà il numero di volte in cui viene trovato il listener nell'elenco dei listener dell'evento.

function listenerCount<K>(eventName: string | symbol, listener?: Function): number

Parametri

eventName

string | symbol

Nome dell'evento in ascolto

listener

Function

Funzione del gestore eventi

Restituisce

number

Ereditato da EventEmitter.listenerCount

listeners<K>(string | symbol)

Restituisce una copia della matrice di listener per l'evento denominato 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[]

Parametri

eventName

string | symbol

Restituisce

Function[]

Ereditato da EventEmitter.listener

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

Alias per emitter.removeListener().

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

DeviceTransport

Ereditato da EventEmitter.off

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

Aggiunge una funzione monousolistener per l'evento denominato eventName. Al successivo eventName attivazione, questo listener viene rimosso e quindi richiamato.

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

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.

Per impostazione predefinita, i listener di eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il emitter.prependOnceListener() metodo può essere usato come alternativa per aggiungere il listener di eventi all'inizio della matrice listener.

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

DeviceTransport

Ereditato da EventEmitter.once

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

Aggiunge la listener funzione all'inizio della matrice listener per l'evento denominato eventName. Non vengono effettuati controlli per verificare se è già stato aggiunto .listener Più chiamate che passano la stessa combinazione di eventName e listener comportano l'aggiunta listener e la chiamata, più volte.

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

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

DeviceTransport

Ereditato da EventEmitter.prependListener

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

Aggiunge una funzione monousolistener per l'evento denominato eventNameall'inizio della matrice listener. La volta eventName successiva viene attivata, questo listener viene rimosso e quindi richiamato.

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

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

DeviceTransport

Ereditato da EventEmitter.prependOnceListener

rawListeners<K>(string | symbol)

Restituisce una copia della matrice di listener per l'evento denominato eventName, inclusi eventuali wrapper, ad esempio quelli creati da .once().

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

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

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

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

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

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

function rawListeners<K>(eventName: string | symbol): Function[]

Parametri

eventName

string | symbol

Restituisce

Function[]

Ereditato da EventEmitter.rawListeners

removeAllListeners(string | symbol)

Rimuove tutti i listener o quelli dell'oggetto specificato eventName.

È consigliabile rimuovere listener aggiunti altrove nel codice, in particolare quando l'istanza EventEmitter è stata creata da un altro componente o modulo ,ad esempio socket o flussi di file.

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.

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

Parametri

eventName

string | symbol

Restituisce

DeviceTransport

Ereditato da EventEmitter.removeAllListeners

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

Rimuove l'oggetto specificato listener dalla matrice del listener per l'evento denominato eventName.

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

removeListener() rimuoverà al massimo un'istanza di un listener dalla matrice del listener. Se un listener singolo è stato aggiunto più volte alla matrice del listener per l'oggetto specificato eventName, removeListener() è necessario chiamare più volte per rimuovere ogni istanza.

Una volta generato un evento, tutti i listener collegati al listener al momento dell'emissione vengono chiamati in ordine. Ciò implica che qualsiasi removeListener() chiamata o removeAllListeners()dopo l'emissione e prima che l'ultimo listener finisca l'esecuzione non li rimuoverà daemit() in corso. Gli eventi successivi si comportano come previsto.

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

Poiché i listener vengono gestiti tramite una matrice interna, la chiamata di questa operazione modificherà gli indici di posizione di qualsiasi listener registrato dopo la rimozione del listener. Ciò non influirà sull'ordine in cui vengono chiamati i listener, ma significa che tutte le copie della matrice del listener restituite dal emitter.listeners() metodo dovranno essere ricreate.

Quando una singola funzione è stata aggiunta più volte come gestore per un singolo evento (come nell'esempio seguente), removeListener() rimuoverà l'istanza aggiunta più di recente. Nell'esempio il once('ping') listener viene rimosso:

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

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

DeviceTransport

Ereditato da EventEmitter.removeListener

setMaxListeners(number)

Per impostazione predefinita EventEmitter, verrà visualizzato un avviso se vengono aggiunti più 10 listener per un determinato evento. Si tratta di un valore predefinito utile che consente di trovare perdite di memoria. Il emitter.setMaxListeners() metodo consente di modificare il limite per questa istanza specifica EventEmitter . Il valore può essere impostato su Infinity (o 0) per indicare un numero illimitato di listener.

Restituisce un riferimento a EventEmitter, in modo che le chiamate possano essere concatenati.

function setMaxListeners(n: number): DeviceTransport

Parametri

n

number

Restituisce

DeviceTransport

Ereditato da EventEmitter.setMaxListeners

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

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

Parametri

error

Error

event

string | symbol

args

AnyRest

Ereditato da EventEmitter.__@captureRejectionSymbol@145