DeviceTransport interface

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

Restituisce

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

Parametri

Restituisce

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

Parametri

Restituisce

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

Parametri

Restituisce

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

Parametri

Restituisce

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

Parametri

Restituisce

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

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

Parametri

Alias per emitter.on(eventName, listener).

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

Parametri

Restituisce

Ereditato da EventEmitter.addListener

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

Restituisce true se l'evento include 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

Restituisce

Ereditato da EventEmitter.emit

Restituisce una matrice che elenca gli eventi per i quali l'emettitore ha registrato listener. I valori nella 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

Ereditato da EventEmitter.eventNames

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

function getMaxListeners(): number

Restituisce

ereditato da EventEmitter.getMaxListeners

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

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

Parametri

Restituisce

Ereditato da EventEmitter.listenerCount

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

Restituisce

Ereditato da EventEmitter.listener

Alias per emitter.removeListener().

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

Parametri

Restituisce

Ereditato da EventEmitter.off

Aggiunge un funzione dilistener una tantum per l'evento denominato eventName. La volta successiva che viene attivata eventName, questo listener viene rimosso e quindi richiamato.

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

Restituisce un riferimento alla 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 metodo emitter.prependOnceListener() può essere usato come alternativa per aggiungere il listener di eventi all'inizio della matrice di 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

Restituisce

ereditato da EventEmitter.once

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

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

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

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

Parametri

Restituisce

Ereditato da EventEmitter.prependListener

Aggiunge una funzione di una tantum per l'evento denominato all'che inizia della matrice listener. Alla successiva attivazione di eventName, questo listener viene rimosso e quindi richiamato.

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

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

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

Parametri

Restituisce

Ereditato da EventEmitter.prependOnceListener

Restituisce una copia della matrice di listener per l'evento denominato eventName, inclusi tutti i 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

Restituisce

ereditato da EventEmitter.rawListeners

Rimuove tutti i listener o quelli del eventNamespecificato.

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

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

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

Parametri

Restituisce

Ereditato da EventEmitter.removeAllListeners

Rimuove il listener specificato dalla matrice di 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 di listener per il eventNamespecificato, removeListener() deve essere chiamato 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 o chiamate dopo l'emissione e l' prima che l'ultima esecuzione del listener non li rimuoverà dal 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 usando una matrice interna, la chiamata di questo 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 metodo emitter.listeners() 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 listener once('ping') 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 alla EventEmitter, in modo che le chiamate possano essere concatenati.

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

Parametri

Restituisce

Ereditato da EventEmitter.removeListener

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

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

function setMaxListeners(n: number): DeviceTransport

Parametri

Restituisce

Ereditato da EventEmitter.setMaxListeners

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

Parametri

ereditato da EventEmitter.__@captureRejectionSymbol@141