Condividi tramite

Transport interface

  • Riferimento
Pacchetto:
azure-iothub
Extends

EventEmitter

Metodi

connect(Callback<Connected>)
disconnect(Callback<Disconnected>)
getFeedbackReceiver(Callback<ServiceReceiver>)
getFileNotificationReceiver(Callback<ServiceReceiver>)
send(string, Message, Callback<MessageEnqueued>)

Metodi ereditati

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

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

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

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

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

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

Aggiunge la funzione listener alla fine 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.on('connection', (stream) => {
  console.log('someone connected!');
});

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.prependListener() 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.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
once<K>(string | symbol, (args: any[]) => void)

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

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

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.
rawListeners<K>(string | symbol)

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

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

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.
setMaxListeners(number)

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.
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Dettagli metodo

connect(Callback<Connected>) 

function connect(done?: Callback<Connected>)

Parametri

done

Callback<Connected>

disconnect(Callback<Disconnected>) 

function disconnect(done: Callback<Disconnected>)

Parametri

done

Callback<Disconnected>

getFeedbackReceiver(Callback<ServiceReceiver>) 

function getFeedbackReceiver(done: Callback<ServiceReceiver>)

Parametri

done

Callback<ServiceReceiver>

getFileNotificationReceiver(Callback<ServiceReceiver>) 

function getFileNotificationReceiver(done: Callback<ServiceReceiver>)

Parametri

done

Callback<ServiceReceiver>

send(string, Message, Callback<MessageEnqueued>) 

function send(deviceId: string, message: Message, done?: Callback<MessageEnqueued>)

Parametri

deviceId

string

message

Message

done

Callback<MessageEnqueued>

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

Transport

Ereditato da EventEmitter.addListener

emit<K>(string | symbol, AnyRest)

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

eventName

string | symbol

args

AnyRest

Restituisce

boolean

Ereditato da EventEmitter.emit

eventNames()

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

(string | symbol)[]

Ereditato da EventEmitter.eventNames

getMaxListeners()

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

number

ereditato da EventEmitter.getMaxListeners

listenerCount<K>(string | symbol, Function)

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

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

Transport

Ereditato da EventEmitter.off

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

Aggiunge la funzione listener alla fine 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.on('connection', (stream) => {
  console.log('someone connected!');
});

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.prependListener() 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.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): Transport

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

Transport

Ereditato da EventEmitter.on

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

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

Transport

ereditato da EventEmitter.once

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

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

Transport

Ereditato da EventEmitter.prependListener

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

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

Transport

Ereditato da EventEmitter.prependOnceListener

rawListeners<K>(string | symbol)

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

eventName

string | symbol

Restituisce

Function[]

ereditato da EventEmitter.rawListeners

removeAllListeners(string | symbol)

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

Parametri

eventName

string | symbol

Restituisce

Transport

Ereditato da EventEmitter.removeAllListeners

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

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

Transport

Ereditato da EventEmitter.removeListener

setMaxListeners(number)

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

Parametri

n

number

Restituisce

Transport

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@118