Condividi tramite

Client class

  • Riferimento
Pacchetto:
azure-iothub

Il client del servizio hub IoT viene usato per comunicare con i dispositivi tramite un hub IoT di Azure. Consente all'utente dell'SDK di:

  • inviare il cloud a dispositivo (noto anche come comandi) ai dispositivi: i comandi vengono accodati in hub IoT e recapitati in modo asincrono solo quando il dispositivo è connesso. Solo 50 comandi possono essere accodati per dispositivo.
  • richiamare metodi diretti nei dispositivi (che funzioneranno solo se il dispositivo è attualmente connesso: è un modo sincrono di comunicare con il dispositivo)
  • ascoltare i messaggi di feedback inviati dai dispositivi per i comandi precedenti.
  • ascoltare le notifiche di caricamento dei file dai dispositivi.

Gli utenti devono creare nuove Client istanze chiamando uno dei metodi factory, daConnectionString o daSharedAccessSignature, per creare un client del servizio hub IoT.

Extends

EventEmitter

Proprietà ereditate

captureRejections

Valore: booleano

Modificare l'opzione predefinita captureRejections in tutti i nuovi EventEmitter oggetti.
captureRejectionSymbol

Valore: Symbol.for('nodejs.rejection')

Vedere come scrivere un oggetto personalizzato rejection handler.
defaultMaxListeners

Per impostazione predefinita, è possibile registrare un massimo di 10 listener per qualsiasi singolo evento. Questo limite può essere modificato per singole EventEmitter istanze usando il emitter.setMaxListeners(n) metodo . Per modificare il valore predefinito per tutte leEventEmitter istanze, la events.defaultMaxListeners proprietà può essere usata. Se questo valore non è un numero positivo, viene generato un RangeError valore.

Prestare attenzione quando si imposta l'oggetto events.defaultMaxListeners perché la modifica influisce su tutte leEventEmitter istanze, incluse quelle create prima che venga apportata la modifica. Tuttavia, la chiamata emitter.setMaxListeners(n) ha ancora la precedenza su events.defaultMaxListeners.

Questo non è un limite rigido. L'istanza EventEmitter consentirà di aggiungere più listener, ma restituirà un avviso di traccia a stderr che indica che è stata rilevata una "possibile perdita di memoria EventEmitter". Per qualsiasi singolo EventEmittermetodo , è possibile usare i emitter.getMaxListeners() metodi e emitter.setMaxListeners() per evitare temporaneamente questo avviso:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

Il --trace-warnings flag della riga di comando può essere usato per visualizzare la traccia dello stack per tali avvisi.

L'avviso generato può essere controllato con process.on('warning') e avrà le proprietà aggiuntive emitter, typee count , facendo riferimento all'istanza dell'emittente dell'evento, al nome dell'evento e al numero di listener collegati, rispettivamente. La proprietà name è impostata su 'MaxListenersExceededWarning'.
errorMonitor

Questo simbolo deve essere usato per installare un listener solo per gli eventi di monitoraggio 'error' . I listener installati usando questo simbolo vengono chiamati prima che vengano chiamati i listener regolari 'error' .

L'installazione di un listener usando questo simbolo non modifica il comportamento dopo che viene generato un 'error' evento. Pertanto, il processo si arresterà in modo anomalo se non è installato alcun listener regolare 'error' .

Metodi

close()
close(IncomingMessageCallback<Disconnected>)

Chiude la connessione a un hub IoT.
fromConnectionString(string, TransportCtor)

Crea un client del servizio hub IoT dall'stringa di connessione specificato usando il trasporto predefinito (Amqp) o quello specificato nel secondo argomento.
fromSharedAccessSignature(string, TransportCtor)

Crea un client del servizio hub IoT dalla firma di accesso condiviso specificata usando il trasporto predefinito (Amqp) o quello specificato nel secondo argomento.
fromTokenCredential(string, TokenCredential, TransportCtor)

Crea un client del servizio hub IoT dall'oggetto tokenCredential di Azure specificato usando il trasporto predefinito (Amqp) o quello specificato nel secondo argomento.
getFeedbackReceiver()
getFeedbackReceiver(IncomingMessageCallback<ServiceReceiver>)

Restituisce un oggetto AmqpReceiver che genera eventi quando vengono ricevuti nuovi messaggi di feedback dal client.
getFileNotificationReceiver()
getFileNotificationReceiver(IncomingMessageCallback<ServiceReceiver>)

Restituisce un oggetto AmqpReceiver che genera eventi quando vengono ricevute dal client nuove notifiche di caricamento dei file.
invokeDeviceMethod(string, DeviceMethodParams)
invokeDeviceMethod(string, DeviceMethodParams, IncomingMessageCallback<any>)

Richiama un metodo in un determinato dispositivo o modulo.
invokeDeviceMethod(string, string, DeviceMethodParams)
invokeDeviceMethod(string, string, DeviceMethodParams, IncomingMessageCallback<any>)
open()
open(IncomingMessageCallback<Connected>)

Apre la connessione a un hub IoT.
send(string, Message | BufferConvertible)
send(string, Message | BufferConvertible, IncomingMessageCallback<MessageEnqueued>)

Invia un messaggio a un dispositivo.
setRetryPolicy(RetryPolicy)

Impostare i criteri usati dal client per ripetere le operazioni di rete.

Metodi ereditati

addAbortListener(AbortSignal, (event: Event) => void)

Ascolta una sola volta l'evento nell'oggetto abort specificato signal.

L'ascolto dell'evento abort sui segnali di interruzione non è sicuro e può causare perdite di risorse poiché un'altra terza parte con il segnale può chiamare e.stopImmediatePropagation(). Purtroppo Node.js non può modificare questo perché viola lo standard Web. Inoltre, l'API originale semplifica la rimozione dei listener.

Questa API consente l'uso AbortSignalsicuro di s nelle API Node.js risolvendo questi due problemi ascoltando l'evento in modo che stopImmediatePropagation non impedisca l'esecuzione del listener.

Restituisce un oggetto monouso in modo che possa essere annullata più facilmente.

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}
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) ]
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)

Restituisce una copia della matrice di listener per l'evento denominato eventName.

Per EventEmitterquesto comportamento si comporta esattamente come la chiamata .listeners sull'emittente.

Per EventTargets questo è l'unico modo per ottenere i listener di eventi per la destinazione dell'evento. Ciò è utile per scopi di debug e diagnostica.

import { getEventListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}
getMaxListeners()

Restituisce il valore del listener massimo corrente per il EventEmitter quale è impostato per emitter.setMaxListeners(n) impostazione predefinita o per defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Restituisce la quantità massima attualmente impostata di listener.

Per EventEmitterquesto comportamento si comporta esattamente come la chiamata .getMaxListeners sull'emittente.

Per EventTargets questo è l'unico modo per ottenere i listener di eventi max per la destinazione dell'evento. Se il numero di gestori eventi in un singolo EventTarget supera il set massimo, EventTarget visualizzerà un avviso.

import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Metodo di classe che restituisce il numero di listener per il dato registrato nell'oggetto eventName specificato emitter.

import { EventEmitter, listenerCount } from 'node:events';

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
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(EventEmitter<DefaultEventMap>, string, StaticEventEmitterOptions) 
import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Restituisce un oggetto AsyncIterator che esegue l'iterazione degli eventName eventi. Genererà se l'oggetto EventEmitter genera 'error'. Rimuove tutti i listener quando si chiude il ciclo. L'oggetto value restituito da ogni iterazione è una matrice composta dagli argomenti dell'evento generati.

Può AbortSignal essere usato per annullare l'attesa sugli eventi:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());
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(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

Crea un Promise oggetto che viene soddisfatto quando l'oggetto EventEmitter genera l'evento specificato o che viene rifiutato se l'oggetto genera 'error' durante l'attesaEventEmitter. Verrà Promise risolto con una matrice di tutti gli argomenti generati all'evento specificato.

Questo metodo è intenzionalmente generico e funziona con l'interfaccia EventTarget della piattaforma Web, che non ha semantica di eventi speciali'error' e non ascolta l'evento 'error' .

import { once, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

La gestione speciale dell'evento 'error' viene utilizzata solo quando events.once() viene usata per attendere un altro evento. Se events.once() viene usato per attendere l'evento 'error' stesso, viene considerato come qualsiasi altro tipo di evento senza gestione speciale:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

Un AbortSignal oggetto può essere usato per annullare l'attesa dell'evento:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
once(EventTarget, string, StaticEventEmitterOptions)
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.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Dettagli proprietà ereditate

captureRejections

Valore: booleano

Modificare l'opzione predefinita captureRejections in tutti i nuovi EventEmitter oggetti.

static captureRejections: boolean

Valore della proprietà

boolean

Ereditato da EventEmitter.captureRejections

captureRejectionSymbol

Valore: Symbol.for('nodejs.rejection')

Vedere come scrivere un oggetto personalizzato rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valore della proprietà

typeof captureRejectionSymbol

Ereditato da EventEmitter.captureRejectionSymbol

defaultMaxListeners

Per impostazione predefinita, è possibile registrare un massimo di 10 listener per qualsiasi singolo evento. Questo limite può essere modificato per singole EventEmitter istanze usando il emitter.setMaxListeners(n) metodo . Per modificare il valore predefinito per tutte leEventEmitter istanze, la events.defaultMaxListeners proprietà può essere usata. Se questo valore non è un numero positivo, viene generato un RangeError valore.

Prestare attenzione quando si imposta l'oggetto events.defaultMaxListeners perché la modifica influisce su tutte leEventEmitter istanze, incluse quelle create prima che venga apportata la modifica. Tuttavia, la chiamata emitter.setMaxListeners(n) ha ancora la precedenza su events.defaultMaxListeners.

Questo non è un limite rigido. L'istanza EventEmitter consentirà di aggiungere più listener, ma restituirà un avviso di traccia a stderr che indica che è stata rilevata una "possibile perdita di memoria EventEmitter". Per qualsiasi singolo EventEmittermetodo , è possibile usare i emitter.getMaxListeners() metodi e emitter.setMaxListeners() per evitare temporaneamente questo avviso:

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

Il --trace-warnings flag della riga di comando può essere usato per visualizzare la traccia dello stack per tali avvisi.

L'avviso generato può essere controllato con process.on('warning') e avrà le proprietà aggiuntive emitter, typee count , facendo riferimento all'istanza dell'emittente dell'evento, al nome dell'evento e al numero di listener collegati, rispettivamente. La proprietà name è impostata su 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valore della proprietà

number

Ereditato da EventEmitter.defaultMaxListeners

errorMonitor

Questo simbolo deve essere usato per installare un listener solo per gli eventi di monitoraggio 'error' . I listener installati usando questo simbolo vengono chiamati prima che vengano chiamati i listener regolari 'error' .

L'installazione di un listener usando questo simbolo non modifica il comportamento dopo che viene generato un 'error' evento. Pertanto, il processo si arresterà in modo anomalo se non è installato alcun listener regolare 'error' .

static errorMonitor: typeof errorMonitor

Valore della proprietà

typeof errorMonitor

Ereditato da EventEmitter.errorMonitor

Dettagli metodo

close() 

function close(): Promise<ResultWithIncomingMessage<Disconnected>>

Restituisce

Promise<ResultWithIncomingMessage<Disconnected>>

close(IncomingMessageCallback<Disconnected>)

Chiude la connessione a un hub IoT.

function close(done?: IncomingMessageCallback<Disconnected>)

Parametri

done

IncomingMessageCallback<Disconnected>

Funzione facoltativa da chiamare al termine dell'operazione. done verrà passato un argomento oggetto Error, che sarà null se l'operazione è stata completata correttamente.

fromConnectionString(string, TransportCtor)

Crea un client del servizio hub IoT dall'stringa di connessione specificato usando il trasporto predefinito (Amqp) o quello specificato nel secondo argomento.

static function fromConnectionString(connStr: string, transportCtor?: TransportCtor): Client

Parametri

connStr

string

Un stringa di connessione che incapsula le autorizzazioni "device connect" in un hub IoT.

transportCtor
TransportCtor

Restituisce

Client

fromSharedAccessSignature(string, TransportCtor)

Crea un client del servizio hub IoT dalla firma di accesso condiviso specificata usando il trasporto predefinito (Amqp) o quello specificato nel secondo argomento.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor?: TransportCtor): Client

Parametri

sharedAccessSignature

string

Firma di accesso condiviso che incapsula le autorizzazioni "service connect" in un hub IoT.

transportCtor
TransportCtor

Restituisce

Client

fromTokenCredential(string, TokenCredential, TransportCtor)

Crea un client del servizio hub IoT dall'oggetto tokenCredential di Azure specificato usando il trasporto predefinito (Amqp) o quello specificato nel secondo argomento.

static function fromTokenCredential(hostName: string, tokenCredential: TokenCredential, transportCtor?: TransportCtor): Client

Parametri

hostName

string

Nome host del servizio di Azure.

tokenCredential
TokenCredential

Un token di AzureCredential usato per l'autenticazione con il servizio di Azure

transportCtor
TransportCtor

Restituisce

Client

getFeedbackReceiver() 

function getFeedbackReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

Restituisce

Promise<ResultWithIncomingMessage<ServiceReceiver>>

getFeedbackReceiver(IncomingMessageCallback<ServiceReceiver>)

Restituisce un oggetto AmqpReceiver che genera eventi quando vengono ricevuti nuovi messaggi di feedback dal client.

function getFeedbackReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Parametri

done

IncomingMessageCallback<ServiceReceiver>

Funzione facoltativa da chiamare al termine dell'operazione. done verrà chiamato con due argomenti: un oggetto Error (può essere null) e un oggetto AmqpReceiver.

getFileNotificationReceiver() 

function getFileNotificationReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

Restituisce

Promise<ResultWithIncomingMessage<ServiceReceiver>>

getFileNotificationReceiver(IncomingMessageCallback<ServiceReceiver>)

Restituisce un oggetto AmqpReceiver che genera eventi quando vengono ricevute dal client nuove notifiche di caricamento dei file.

function getFileNotificationReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Parametri

done

IncomingMessageCallback<ServiceReceiver>

Funzione facoltativa da chiamare al termine dell'operazione. done verrà chiamato con due argomenti: un oggetto Error (può essere null) e un oggetto AmqpReceiver.

invokeDeviceMethod(string, DeviceMethodParams) 

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

Parametri

deviceId

string

methodParams
DeviceMethodParams

Restituisce

Promise<ResultWithIncomingMessage<any>>

invokeDeviceMethod(string, DeviceMethodParams, IncomingMessageCallback<any>)

Richiama un metodo in un determinato dispositivo o modulo.

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams, done?: IncomingMessageCallback<any>)

Parametri

deviceId

string

Identificatore di un'identità del dispositivo esistente.

methodParams
DeviceMethodParams
done

IncomingMessageCallback<any>

Callback facoltativo da chiamare con il risultato dell'esecuzione del metodo.

invokeDeviceMethod(string, string, DeviceMethodParams) 

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

Parametri

deviceId

string

moduleId

string

methodParams
DeviceMethodParams

Restituisce

Promise<ResultWithIncomingMessage<any>>

invokeDeviceMethod(string, string, DeviceMethodParams, IncomingMessageCallback<any>) 

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams, done: IncomingMessageCallback<any>)

Parametri

deviceId

string

moduleId

string

methodParams
DeviceMethodParams
done

IncomingMessageCallback<any>

open() 

function open(): Promise<ResultWithIncomingMessage<Connected>>

Restituisce

Promise<ResultWithIncomingMessage<Connected>>

open(IncomingMessageCallback<Connected>)

Apre la connessione a un hub IoT.

function open(done?: IncomingMessageCallback<Connected>)

Parametri

done

IncomingMessageCallback<Connected>

Funzione facoltativa da chiamare al termine dell'operazione. done verrà passato un argomento oggetto Error, che sarà null se l'operazione è stata completata correttamente.

send(string, Message | BufferConvertible) 

function send(deviceId: string, message: Message | BufferConvertible): Promise<ResultWithIncomingMessage<MessageEnqueued>>

Parametri

deviceId

string

message

Message | BufferConvertible

Restituisce

Promise<ResultWithIncomingMessage<MessageEnqueued>>

send(string, Message | BufferConvertible, IncomingMessageCallback<MessageEnqueued>)

Invia un messaggio a un dispositivo.

function send(deviceId: string, message: Message | BufferConvertible, done?: IncomingMessageCallback<MessageEnqueued>)

Parametri

deviceId

string

Identificatore di un'identità del dispositivo esistente.

message

Message | BufferConvertible

Corpo del messaggio da inviare al dispositivo. Se message non è di tipo Message, verrà convertito.

done

IncomingMessageCallback<MessageEnqueued>

Funzione facoltativa da chiamare al termine dell'operazione. done verrà chiamato con due argomenti: un oggetto Error (può essere null) e un oggetto di risposta specifico del trasporto utile per la registrazione o il debug.

setRetryPolicy(RetryPolicy)

Impostare i criteri usati dal client per ripetere le operazioni di rete.

function setRetryPolicy(policy: RetryPolicy)

Parametri

policy

RetryPolicy

criterio usato per ripetere le operazioni , ad esempio aprire, inviare e così via. L'SDK include 2 criteri predefiniti: ExponentialBackoffWithJitter (impostazione predefinita) e NoRetry (per annullare qualsiasi forma di tentativo). L'utente può anche passare il proprio oggetto purché implementi 2 metodi: - shouldRetry(err: Error): boolean : indica se un'operazione deve essere ritrita in base al tipo di errore - nextRetryTimeout(retryCount: number, throttled: boolean): number : restituisce il tempo di attesa (in millisecondi) prima di ripetere i tentativi in base al numero precedente di tentativi (retryCount) e al fatto che l'errore è un errore di limitazione o meno.

Dettagli dei metodi ereditati

addAbortListener(AbortSignal, (event: Event) => void)

Ascolta una sola volta l'evento nell'oggetto abort specificato signal.

L'ascolto dell'evento abort sui segnali di interruzione non è sicuro e può causare perdite di risorse poiché un'altra terza parte con il segnale può chiamare e.stopImmediatePropagation(). Purtroppo Node.js non può modificare questo perché viola lo standard Web. Inoltre, l'API originale semplifica la rimozione dei listener.

Questa API consente l'uso AbortSignalsicuro di s nelle API Node.js risolvendo questi due problemi ascoltando l'evento in modo che stopImmediatePropagation non impedisca l'esecuzione del listener.

Restituisce un oggetto monouso in modo che possa essere annullata più facilmente.

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}

static function addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable

Parametri

signal

AbortSignal

resource

(event: Event) => void

Restituisce

Disposable

Monouso che rimuove il abort listener.

Ereditato da EventEmitter.addAbortListener

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

Alias per emitter.on(eventName, listener).

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

Client

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

getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)

Restituisce una copia della matrice di listener per l'evento denominato eventName.

Per EventEmitterquesto comportamento si comporta esattamente come la chiamata .listeners sull'emittente.

Per EventTargets questo è l'unico modo per ottenere i listener di eventi per la destinazione dell'evento. Ciò è utile per scopi di debug e diagnostica.

import { getEventListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget, name: string | symbol): Function[]

Parametri

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

Restituisce

Function[]

Ereditato da EventEmitter.getEventListeners

getMaxListeners()

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

function getMaxListeners(): number

Restituisce

number

Ereditato da EventEmitter.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Restituisce la quantità massima attualmente impostata di listener.

Per EventEmitterquesto comportamento si comporta esattamente come la chiamata .getMaxListeners sull'emittente.

Per EventTargets questo è l'unico modo per ottenere i listener di eventi max per la destinazione dell'evento. Se il numero di gestori eventi in un singolo EventTarget supera il set massimo, EventTarget visualizzerà un avviso.

import { getMaxListeners, setMaxListeners, EventEmitter } from 'node:events';

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}

static function getMaxListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget): number

Parametri

emitter

EventEmitter<DefaultEventMap> | EventTarget

Restituisce

number

Ereditato da EventEmitter.getMaxListeners

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Avviso

Questa API è ora deprecata.

Since v3.2.0 - Use listenerCount instead.

Metodo di classe che restituisce il numero di listener per il dato registrato nell'oggetto eventName specificato emitter.

import { EventEmitter, listenerCount } from 'node:events';

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

static function listenerCount(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol): number

Parametri

emitter

EventEmitter<DefaultEventMap>

L'emittente da eseguire una query

eventName

string | symbol

Nome evento

Restituisce

number

Ereditato da EventEmitter.listenerCount

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

Client

Ereditato da EventEmitter.off

on(EventEmitter<DefaultEventMap>, string, StaticEventEmitterOptions) 

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Restituisce un oggetto AsyncIterator che esegue l'iterazione degli eventName eventi. Genererà se l'oggetto EventEmitter genera 'error'. Rimuove tutti i listener quando si chiude il ciclo. L'oggetto value restituito da ogni iterazione è una matrice composta dagli argomenti dell'evento generati.

Può AbortSignal essere usato per annullare l'attesa sugli eventi:

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>

Parametri

emitter

EventEmitter<DefaultEventMap>

eventName

string

Nome dell'evento in ascolto

options

StaticEventEmitterOptions

Restituisce

AsyncIterableIterator<any>

Oggetto AsyncIterator che esegue l'iterazione degli eventName eventi generati dall'oggetto emitter

Ereditato da EventEmitter.on

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

Client

Ereditato da EventEmitter.on

once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

Crea un Promise oggetto che viene soddisfatto quando l'oggetto EventEmitter genera l'evento specificato o che viene rifiutato se l'oggetto genera 'error' durante l'attesaEventEmitter. Verrà Promise risolto con una matrice di tutti gli argomenti generati all'evento specificato.

Questo metodo è intenzionalmente generico e funziona con l'interfaccia EventTarget della piattaforma Web, che non ha semantica di eventi speciali'error' e non ascolta l'evento 'error' .

import { once, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

La gestione speciale dell'evento 'error' viene utilizzata solo quando events.once() viene usata per attendere un altro evento. Se events.once() viene usato per attendere l'evento 'error' stesso, viene considerato come qualsiasi altro tipo di evento senza gestione speciale:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

Un AbortSignal oggetto può essere usato per annullare l'attesa dell'evento:

import { EventEmitter, once } from 'node:events';

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

static function once(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>

Parametri

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

Restituisce

Promise<any[]>

Ereditato da EventEmitter.once

once(EventTarget, string, StaticEventEmitterOptions) 

static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>

Parametri

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

Restituisce

Promise<any[]>

Ereditato da EventEmitter.once

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

Client

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

Client

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

Client

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

Parametri

eventName

string | symbol

Restituisce

Client

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

Client

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

Parametri

n

number

Restituisce

Client

Ereditato da EventEmitter.setMaxListeners

setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 

import { setMaxListeners, EventEmitter } from 'node:events';

const target = new EventTarget();
const emitter = new EventEmitter();

setMaxListeners(5, target, emitter);

static function setMaxListeners(n?: number, eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[])

Parametri

n

number

Numero non negativo. Numero massimo di listener per EventTarget evento.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

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