Condividi tramite

ModuleClient class

  • Riferimento
Pacchetto:
azure-iot-device

Client del dispositivo dell'hub IoT usato per connettere un dispositivo con un hub IoT di Azure.

Gli utenti dell'SDK devono chiamare uno dei metodi factory, daConnectionString o daSharedAccessSignature per creare un client del dispositivo dell'hub IoT.

Extends

InternalClient

Proprietà ereditate

captureRejections

Valore: booleano

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

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

Vedere come scrivere un rejection handlerpersonalizzato.
defaultMaxListeners

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

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

Questo non è un limite rigido. L'istanza di EventEmitter consentirà l'aggiunta di più listener, ma restituirà un avviso di traccia a stderr che indica che è stata rilevata una possibile perdita di memoria EventEmitter. Per qualsiasi singolo EventEmitter, è possibile usare i metodi emitter.getMaxListeners() 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 l'analisi 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'emettitore dell'evento, al nome dell'evento e al numero di listener associati rispettivamente. La proprietà name è impostata su 'MaxListenersExceededWarning'.
errorMonitor

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

L'installazione di un listener che usa questo simbolo non modifica il comportamento dopo l'emissione di un evento 'error'. Di conseguenza, il processo si arresterà in modo anomalo se non è installato alcun listener 'error' normale.

Metodi

close()
close(Callback<Disconnected>)

Chiude la connessione di trasporto e elimina definitivamente le risorse client.

Nota: dopo aver chiamato questo metodo, l'oggetto ModuleClient non può essere riutilizzato.
fromAuthenticationProvider(AuthenticationProvider, any)

Crea un client del modulo dell'hub IoT dal metodo di autenticazione specificato e usa il tipo di trasporto specificato.
fromConnectionString(string, any)

Crea un client del dispositivo dell'hub IoT dalla stringa di connessione specificata usando il tipo di trasporto specificato.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)

Crea un client del modulo dell'hub IoT usando le informazioni di configurazione dell'ambiente.

Se esiste una variabile di ambiente denominata EdgeHubConnectionString o IotHubConnectionString, tale valore viene usato e il comportamento è identico a chiamare fromConnectionString passando tale valore. Se tali variabili di ambiente non esistono, è necessario definire le variabili seguenti:

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"
fromSharedAccessSignature(string, any)

Crea un client del modulo dell'hub IoT dalla firma di accesso condiviso specificata usando il tipo di trasporto specificato.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)

Richiama un metodo in un dispositivo downstream o in un altro modulo nello stesso dispositivo IoTEdge. Si noti che questa funzionalità funziona solo quando il modulo viene eseguito come parte di un dispositivo IoTEdge.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Registra un callback per un metodo denominato methodName.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Invia un evento all'output del modulo specificato
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Invia una matrice di eventi all'output del modulo specificato
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Passa le opzioni all'oggetto ModuleClient che può essere utilizzato per configurare il trasporto.

Metodi ereditati

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addAbortListener(AbortSignal, (event: Event) => void)

Ascolta una volta l'evento abort nel signalfornito.

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

Questa API consente di usare in modo sicuro AbortSignalnelle API di Node.js risolvendo questi due problemi ascoltando l'evento in modo che stopImmediatePropagation non impedisca l'esecuzione del listener.

Restituisce un oggetto eliminabile in modo che possa essere annullato 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).
complete(Message)
complete(Message, Callback<MessageCompleted>)
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) ]
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 di .listeners sull'emettitore.

Per EventTargetquesto è 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 massimo del listener corrente per il EventEmitter impostato da emitter.setMaxListeners(n) o per impostazione predefinita su defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Restituisce la quantità massima di listener attualmente impostata.

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

Per EventTargetquesto è l'unico modo per ottenere i listener di eventi massimi 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
}
getTwin()
getTwin(Callback<Twin>)
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Metodo di classe che restituisce il numero di listener per il eventName specificato registrato nel emitterspecificato.

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 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(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions) 
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 AsyncIterator che esegue l'iterazione degli eventi eventName. Verrà generata se il EventEmitter genera 'error'. Rimuove tutti i listener quando si esce dal ciclo. Il value restituito da ogni iterazione è una matrice composta dagli argomenti dell'evento generati.

È possibile usare un AbortSignal per annullare l'attesa degli 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());

Usare l'opzione close per specificare una matrice di nomi di eventi che termineranno l'iterazione:

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);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
on(EventTarget, string, StaticEventEmitterIteratorOptions)
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(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

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

Questo metodo è intenzionalmente generico e funziona con la piattaforma Web 'interfaccia eventTarget, che non ha una semantica di eventi'error' speciale e non è in ascolto dell'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 usata 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 una 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

È possibile usare un AbortSignal 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 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
open()
open(Callback<Connected>)
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');
reject(Message)
reject(Message, Callback<MessageRejected>)
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.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
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.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

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

setMaxListeners(5, target, emitter);
setRetryPolicy(RetryPolicy)

Imposta i criteri di ripetizione dei tentativi usati dal client in tutte le operazioni. Il valore predefinito è ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Dettagli proprietà ereditate

captureRejections

Valore: booleano

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

static captureRejections: boolean

Valore della proprietà

boolean

Ereditato da InternalClient.captureRejections

captureRejectionSymbol

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

Vedere come scrivere un rejection handlerpersonalizzato.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valore della proprietà

typeof captureRejectionSymbol

Ereditato da InternalClient.captureRejectionSymbol

defaultMaxListeners

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

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

Questo non è un limite rigido. L'istanza di EventEmitter consentirà l'aggiunta di più listener, ma restituirà un avviso di traccia a stderr che indica che è stata rilevata una possibile perdita di memoria EventEmitter. Per qualsiasi singolo EventEmitter, è possibile usare i metodi emitter.getMaxListeners() 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 l'analisi 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'emettitore dell'evento, al nome dell'evento e al numero di listener associati rispettivamente. La proprietà name è impostata su 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valore della proprietà

number

Ereditato da InternalClient.defaultMaxListeners

errorMonitor

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

L'installazione di un listener che usa questo simbolo non modifica il comportamento dopo l'emissione di un evento 'error'. Di conseguenza, il processo si arresterà in modo anomalo se non è installato alcun listener 'error' normale.

static errorMonitor: typeof errorMonitor

Valore della proprietà

typeof errorMonitor

Ereditato da InternalClient.errorMonitor

Dettagli metodo

close() 

function close(): Promise<Disconnected>

Restituisce

Promise<Disconnected>

close(Callback<Disconnected>)

Chiude la connessione di trasporto e elimina definitivamente le risorse client.

Nota: dopo aver chiamato questo metodo, l'oggetto ModuleClient non può essere riutilizzato.

function close(closeCallback?: Callback<Disconnected>)

Parametri

closeCallback

Callback<Disconnected>

Funzione facoltativa da chiamare dopo la disconnessione del trasporto e la chiusura del client.

fromAuthenticationProvider(AuthenticationProvider, any)

Crea un client del modulo dell'hub IoT dal metodo di autenticazione specificato e usa il tipo di trasporto specificato.

static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): ModuleClient

Parametri

authenticationProvider

AuthenticationProvider

Oggetto usato per ottenere i parametri di autenticazione per l'hub IoT.

transportCtor

any

Protocollo di trasporto usato per connettersi all'hub IoT.

Restituisce

ModuleClient

fromConnectionString(string, any)

Crea un client del dispositivo dell'hub IoT dalla stringa di connessione specificata usando il tipo di trasporto specificato.

static function fromConnectionString(connStr: string, transportCtor: any): ModuleClient

Parametri

connStr

string

Stringa di connessione che incapsula le autorizzazioni di "connessione del dispositivo" in un hub IoT.

transportCtor

any

Costruttore di trasporto.

Restituisce

ModuleClient

fromEnvironment(any) 

static function fromEnvironment(transportCtor: any): Promise<ModuleClient>

Parametri

transportCtor

any

Restituisce

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Crea un client del modulo dell'hub IoT usando le informazioni di configurazione dell'ambiente.

Se esiste una variabile di ambiente denominata EdgeHubConnectionString o IotHubConnectionString, tale valore viene usato e il comportamento è identico a chiamare fromConnectionString passando tale valore. Se tali variabili di ambiente non esistono, è necessario definire le variabili seguenti:

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"

static function fromEnvironment(transportCtor: any, callback?: Callback<ModuleClient>)

Parametri

transportCtor

any

Protocollo di trasporto usato per connettersi all'hub IoT.

callback

Callback<ModuleClient>

Callback facoltativo da richiamare quando ModuleClient è stato costruito o se si verifica un errore durante la creazione del client.

fromSharedAccessSignature(string, any)

Crea un client del modulo dell'hub IoT dalla firma di accesso condiviso specificata usando il tipo di trasporto specificato.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): ModuleClient

Parametri

sharedAccessSignature

string

Firma di accesso condiviso che incapsula le autorizzazioni di "connessione del dispositivo" in un hub IoT.

transportCtor

any

Restituisce

ModuleClient

invokeMethod(string, MethodParams) 

function invokeMethod(deviceId: string, methodParams: MethodParams): Promise<MethodResult>

Parametri

deviceId

string

methodParams

MethodParams

Restituisce

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Richiama un metodo in un dispositivo downstream o in un altro modulo nello stesso dispositivo IoTEdge. Si noti che questa funzionalità funziona solo quando il modulo viene eseguito come parte di un dispositivo IoTEdge.

function invokeMethod(deviceId: string, methodParams: MethodParams, callback?: Callback<MethodResult>)

Parametri

deviceId

string

identificatore del dispositivo di destinazione

methodParams

MethodParams

parametri della chiamata al metodo diretto

callback

Callback<MethodResult>

callback facoltativo che verrà richiamato con un oggetto Error o il risultato della chiamata al metodo.

invokeMethod(string, string, MethodParams) 

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams): Promise<MethodResult>

Parametri

deviceId

string

moduleId

string

methodParams

MethodParams

Restituisce

Promise<MethodResult>

invokeMethod(string, string, MethodParams, Callback<MethodResult>) 

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams, callback: Callback<MethodResult>)

Parametri

deviceId

string

moduleId

string

methodParams

MethodParams

callback

Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Registra un callback per un metodo denominato methodName.

function onMethod(methodName: string, callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Parametri

methodName

string

Nome del metodo che verrà gestito dal callback

callback

DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

Funzione che deve essere chiamata ogni volta che viene ricevuta una richiesta di metodo per il metodo denominato methodName.

sendOutputEvent(string, Message) 

function sendOutputEvent(outputName: string, message: Message): Promise<MessageEnqueued>

Parametri

outputName

string

message
Message

Restituisce

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Invia un evento all'output del modulo specificato

function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)

Parametri

outputName

string

Nome dell'output a cui inviare l'evento

message
Message

Messaggio da inviare all'output specificato

callback

Callback<MessageEnqueued>

Funzione facoltativa da chiamare quando l'operazione è stata accodata.

sendOutputEventBatch(string, Message[]) 

function sendOutputEventBatch(outputName: string, messages: Message[]): Promise<MessageEnqueued>

Parametri

outputName

string

messages

Message[]

Restituisce

Promise<MessageEnqueued>

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Invia una matrice di eventi all'output del modulo specificato

function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)

Parametri

outputName

string

Nome dell'output a cui inviare gli eventi

messages

Message[]

callback

Callback<MessageEnqueued>

Funzione da chiamare quando le operazioni sono state accodate.

setOptions(DeviceClientOptions) 

function setOptions(options: DeviceClientOptions): Promise<TransportConfigured>

Parametri

options
DeviceClientOptions

Restituisce

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Passa le opzioni all'oggetto ModuleClient che può essere utilizzato per configurare il trasporto.

function setOptions(options: DeviceClientOptions, done?: Callback<TransportConfigured>)

Parametri

options
DeviceClientOptions

Oggetto DeviceClientOptions .

done

Callback<TransportConfigured>

Callback facoltativo da chiamare dopo aver impostato le opzioni.

Dettagli dei metodi ereditati

abandon(Message) 

function abandon(message: Message): Promise<MessageAbandoned>

Parametri

message
Message

Restituisce

Promise<MessageAbandoned>

Ereditato da InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>) 

function abandon(message: Message, abandonCallback: Callback<MessageAbandoned>)

Parametri

message
Message
abandonCallback

Callback<MessageAbandoned>

Ereditato da InternalClient.abandon

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

Ascolta una volta l'evento abort nel signalfornito.

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

Questa API consente di usare in modo sicuro AbortSignalnelle API di Node.js risolvendo questi due problemi ascoltando l'evento in modo che stopImmediatePropagation non impedisca l'esecuzione del listener.

Restituisce un oggetto eliminabile in modo che possa essere annullato 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

Elimina che rimuove il listener abort.

Ereditato da InternalClient.addAbortListener

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

Alias per emitter.on(eventName, listener).

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

ModuleClient

Ereditato da InternalClient.addListener

complete(Message) 

function complete(message: Message): Promise<MessageCompleted>

Parametri

message
Message

Restituisce

Promise<MessageCompleted>

Ereditato da InternalClient.complete

complete(Message, Callback<MessageCompleted>) 

function complete(message: Message, completeCallback: Callback<MessageCompleted>)

Parametri

message
Message
completeCallback

Callback<MessageCompleted>

Ereditato da InternalClient.complete

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 InternalClient.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 InternalClient.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 di .listeners sull'emettitore.

Per EventTargetquesto è 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 InternalClient.getEventListeners

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 InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Restituisce la quantità massima di listener attualmente impostata.

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

Per EventTargetquesto è l'unico modo per ottenere i listener di eventi massimi 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 InternalClient.getMaxListeners

getTwin() 

function getTwin(): Promise<Twin>

Restituisce

Promise<Twin>

ereditato da InternalClient.getTwin

getTwin(Callback<Twin>) 

function getTwin(done: Callback<Twin>)

Parametri

done

Callback<Twin>

ereditato da InternalClient.getTwin

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 eventName specificato registrato nel emitterspecificato.

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'emettitore su cui eseguire una query

eventName

string | symbol

Nome dell'evento

Restituisce

number

Ereditato da InternalClient.listenerCount

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 InternalClient.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 InternalClient.listener

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

Alias per emitter.removeListener().

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

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

ModuleClient

Ereditato da InternalClient.off

on(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions) 

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 AsyncIterator che esegue l'iterazione degli eventi eventName. Verrà generata se il EventEmitter genera 'error'. Rimuove tutti i listener quando si esce dal ciclo. Il value restituito da ogni iterazione è una matrice composta dagli argomenti dell'evento generati.

È possibile usare un AbortSignal per annullare l'attesa degli 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());

Usare l'opzione close per specificare una matrice di nomi di eventi che termineranno l'iterazione:

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);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parametri

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

Restituisce

AsyncIterator<any[], any, any>

Un AsyncIterator che esegue l'iterazione degli eventi eventName generati dal emitter

Ereditato da InternalClient.on

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Parametri

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

Restituisce

AsyncIterator<any[], any, any>

Ereditato da InternalClient.on

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

ModuleClient

Ereditato da InternalClient.on

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

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

Questo metodo è intenzionalmente generico e funziona con la piattaforma Web 'interfaccia eventTarget, che non ha una semantica di eventi'error' speciale e non è in ascolto dell'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 usata 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 una 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

È possibile usare un AbortSignal 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 InternalClient.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 InternalClient.once

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

ModuleClient

Ereditato da InternalClient.once

open() 

function open(): Promise<Connected>

Restituisce

Promise<Connected>

Ereditato da InternalClient.open

open(Callback<Connected>) 

function open(openCallback: Callback<Connected>)

Parametri

openCallback

Callback<Connected>

Ereditato da InternalClient.open

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

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

ModuleClient

Ereditato da InternalClient.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): ModuleClient

Parametri

eventName

string | symbol

Nome dell'evento.

listener

(args: any[]) => void

Funzione di callback

Restituisce

ModuleClient

Ereditato da InternalClient.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 InternalClient.rawListeners

reject(Message) 

function reject(message: Message): Promise<MessageRejected>

Parametri

message
Message

Restituisce

Promise<MessageRejected>

Ereditato da InternalClient.reject

reject(Message, Callback<MessageRejected>) 

function reject(message: Message, rejectCallback: Callback<MessageRejected>)

Parametri

message
Message
rejectCallback

Callback<MessageRejected>

Ereditato da InternalClient.reject

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

Parametri

eventName

string | symbol

Restituisce

ModuleClient

Ereditato da InternalClient.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): ModuleClient

Parametri

eventName

string | symbol

listener

(args: any[]) => void

Restituisce

ModuleClient

Ereditato da InternalClient.removeListener

sendEvent(Message) 

function sendEvent(message: Message): Promise<MessageEnqueued>

Parametri

message
Message

Restituisce

Promise<MessageEnqueued>

ereditato da InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>) 

function sendEvent(message: Message, sendEventCallback: Callback<MessageEnqueued>)

Parametri

message
Message
sendEventCallback

Callback<MessageEnqueued>

ereditato da InternalClient.sendEvent

sendEventBatch(Message[]) 

function sendEventBatch(messages: Message[]): Promise<MessageEnqueued>

Parametri

messages

Message[]

Restituisce

Promise<MessageEnqueued>

ereditato da InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>) 

function sendEventBatch(messages: Message[], sendEventBatchCallback: Callback<MessageEnqueued>)

Parametri

messages

Message[]

sendEventBatchCallback

Callback<MessageEnqueued>

ereditato da InternalClient.sendEventBatch

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

Parametri

n

number

Restituisce

ModuleClient

Ereditato da InternalClient.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 evento EventTarget.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

Zero o più istanze di {EventTarget} o {EventEmitter}. Se non viene specificato alcun valore, n viene impostato come valore massimo predefinito per tutti gli oggetti {EventTarget} e {EventEmitter} appena creati.

Ereditato da InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Imposta i criteri di ripetizione dei tentativi usati dal client in tutte le operazioni. Il valore predefinito è ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parametri

policy

RetryPolicy

{RetryPolicy} Criteri di ripetizione dei tentativi da usare per tutte le operazioni future.

Ereditato da InternalClient.setRetryPolicy

setTransportOptions(any) 

function setTransportOptions(options: any): Promise<TransportConfigured>

Parametri

options

any

Restituisce

Promise<TransportConfigured>

Ereditato da InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>) 

function setTransportOptions(options: any, done: Callback<TransportConfigured>)

Parametri

options

any

done

Callback<TransportConfigured>

Ereditato da InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>) 

function updateSharedAccessSignature(sharedAccessSignature: string, updateSasCallback?: Callback<SharedAccessSignatureUpdated>)

Parametri

sharedAccessSignature

string

updateSasCallback

Callback<SharedAccessSignatureUpdated>

Ereditato da InternalClient.updateSharedAccessSignature

[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 InternalClient.__@captureRejectionSymbol@141