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

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

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

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

Per impostazione predefinita, i listener eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il emitter.prependListener() metodo può essere usato come alternativa per aggiungere il listener eventi all'inizio della matrice listener dei 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 una funzione una sola voltalistener per l'evento denominato eventName. La volta successiva eventName viene attivata, 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 eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il emitter.prependOnceListener() metodo può essere usato come alternativa per aggiungere il listener eventi all'inizio della matrice listener dei 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 l'oggetto listener è già stato aggiunto. Più chiamate passando 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 una sola voltalistener per l'evento denominato eventNameall'inizio della matrice listener. La volta successiva eventName 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 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 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 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 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 a esso al momento dell'emissione vengono chiamati in ordine. Ciò implica che qualsiasi removeListener() o removeAllListeners() chiamata dopo l'emissione e prima che l'ultimo listener finisca l'esecuzione non li rimuoverà dall'avanzamentoemit() . 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 cambierà gli indici di posizione di qualsiasi listener registrato dopo la rimozione del listener. Ciò non influisce sull'ordine in cui vengono chiamati i listener, ma significa che tutte le copie della matrice del listener restituito dal emitter.listeners() metodo dovranno essere ricreate.

Quando una singola funzione è stata aggiunta come gestore più volte 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à stampato 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

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

Transport

Ereditato da EventEmitter.off

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

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

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

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

Per impostazione predefinita, i listener eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il emitter.prependListener() metodo può essere usato come alternativa per aggiungere il listener eventi all'inizio della matrice listener dei 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 una funzione una sola voltalistener per l'evento denominato eventName. La volta successiva eventName viene attivata, 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 eventi vengono richiamati nell'ordine in cui vengono aggiunti. Il emitter.prependOnceListener() metodo può essere usato come alternativa per aggiungere il listener eventi all'inizio della matrice listener dei 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 listener funzione all'inizio della matrice listener per l'evento denominato eventName. Non vengono effettuati controlli per verificare se l'oggetto listener è già stato aggiunto. Più chiamate passando 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): 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 una sola voltalistener per l'evento denominato eventNameall'inizio della matrice listener. La volta successiva eventName 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): 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 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 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): Transport

Parametri

eventName

string | symbol

Restituisce

Transport

Ereditato da EventEmitter.removeAllListeners

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

Rimuove l'oggetto specificato listener 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 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 a esso al momento dell'emissione vengono chiamati in ordine. Ciò implica che qualsiasi removeListener() o removeAllListeners() chiamata dopo l'emissione e prima che l'ultimo listener finisca l'esecuzione non li rimuoverà dall'avanzamentoemit() . 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 cambierà gli indici di posizione di qualsiasi listener registrato dopo la rimozione del listener. Ciò non influisce sull'ordine in cui vengono chiamati i listener, ma significa che tutte le copie della matrice del listener restituito dal emitter.listeners() metodo dovranno essere ricreate.

Quando una singola funzione è stata aggiunta come gestore più volte 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): Transport

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

Transport

Ereditato da EventEmitter.removeListener

setMaxListeners(number)

Per impostazione predefinita EventEmitter, verrà stampato 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): 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@115