Client class

new Client(transport: DeviceTransport, connStr?: string, blobUploadClient?: BlobUploadClient, fileUploadApi?: FileUploadInterface)

Parametri

Valore: booleano

Cambia l'opzione predefinita captureRejections su tutti i nuovi EventEmitter oggetti.

static captureRejections: boolean

Valore della proprietà

Ereditato da InternalClient.captureRifiuti

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

Vedi come scrivere un file personalizzato rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valore della proprietà

Ereditato da InternalClient.captureRejectionSymbol.

Per impostazione predefinita, un massimo di 10 ascoltatori può essere registrato per un singolo evento. Questo limite può essere modificato per singole EventEmitter istanze utilizzando il emitter.setMaxListeners(n) metodo. Per cambiare il valore predefinito per tutteEventEmitter le istanze, si può utilizzare la events.defaultMaxListeners proprietà. Se questo valore non è un numero positivo, si lancia a RangeError .

Fai attenzione quando imposti il events.defaultMaxListeners cambiamento perché la modifica riguarda tutteEventEmitter le istanze, comprese quelle create prima che la modifica venga effettuata. Tuttavia, chiamare emitter.setMaxListeners(n) ha ancora precedenza su events.defaultMaxListeners.

Non è un limite rigido. L'istanza EventEmitter permetterà di aggiungere più ascoltatori ma invierà un avviso di traccia a stderr che indica che è stata rilevata una "possibile perdita di memoria EventEmitter". Per ogni singolo EventEmitter, i emitter.getMaxListeners() metodi e emitter.setMaxListeners() possono essere usati per evitare temporaneamente questo avvertimento:

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 emesso può essere ispezionato con process.on('warning') e avrà le proprietà aggiuntive emitter, type, e count che si riferiscono rispettivamente all'istanza dell'emettitore dell'evento, al nome dell'evento e al numero di ascoltatori collegati. La sua proprietà è impostata name a 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valore della proprietà

Ereditato da InternalClient.defaultMaxListeners

Questo simbolo deve essere utilizzato per installare un ascoltatore solo per il monitoraggio 'error' degli eventi. Gli ascoltatori installati con questo simbolo vengono chiamati prima che vengano chiamati gli ascoltatori regolari 'error' .

L'installazione di un listener usando questo simbolo non cambia il comportamento una volta che un 'error' evento viene emesso. Pertanto, il processo continuerà a crashare se non viene installato un ascoltatore regolare 'error' .

static errorMonitor: typeof errorMonitor

Valore della proprietà

Ereditato da InternalClient.errorMonitor

function close(): Promise<Disconnected>

Valori restituiti

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

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

function close(closeCallback?: Callback<Disconnected>)

Parametri

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

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

Parametri

Valori restituiti

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

Parametri

Valori restituiti

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

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

Parametri

Valori restituiti

function getBlobSharedAccessSignature(blobName: string): Promise<UploadParams>

Parametri

Valori restituiti

Il getBlobSharedAccessSignature ottiene il token di firma di accesso condiviso dell'account di archiviazione collegato dall'hub IoT

function getBlobSharedAccessSignature(blobName: string, callback?: Callback<UploadParams>)

Parametri

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string): Promise<void>

Parametri

Valori restituiti

Il metodo notifyBlobUploadStatus invia all'hub IoT il risultato di un caricamento BLOB.

function notifyBlobUploadStatus(correlationId: string, isSuccess: boolean, statusCode: number, statusDescription: string, callback?: ErrorCallback)

Parametri

Registra un callback per un metodo denominato methodName.

function onDeviceMethod(methodName: string, callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Parametri

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

Parametri

Valori restituiti

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

Parametri

function uploadToBlob(blobName: string, stream: Stream, streamLength: number): Promise<void>

Parametri

Valori restituiti

Il metodo uploadToBlob carica un flusso in un BLOB.

function uploadToBlob(blobName: string, stream: Stream, streamLength: number, callback: ErrorCallback)

Parametri

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

Parametri

Valori restituiti

Ereditato da InternalClient.abandon

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

Parametri

Ereditato da InternalClient.abandon

Ascolta una volta l'evento abort sul sito fornito signal.

Ascoltare l'evento abort sui segnali di aborto è pericoloso e può portare a perdite di risorse poiché un'altra terza parte con il segnale può chiamare e.stopImmediatePropagation(). Purtroppo Node.js non posso cambiare questo perché violerebbe lo standard web. Inoltre, l'API originale rende facile dimenticare di rimuovere gli ascoltatori.

Questa API consente l'uso AbortSignalsicuro di s in Node.js API risolvendo questi due problemi ascoltando l'evento in modo da stopImmediatePropagation non impedire all'ascoltatore di eseguirlo.

Restituisce un usa e getta così da poter essere cancellato 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

Valori restituiti

Usa e getta che toglie l'ascoltatore abort .

Ereditato da InternalClient.addAbortListener

Alias per emitter.on(eventName, listener).

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

Parametri

Valori restituiti

Ereditato da InternalClient.addListener

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

Parametri

Valori restituiti

Ereditato da InternalClient.complete

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

Parametri

Ereditato da InternalClient.complete

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

Valori restituiti

Ereditato da InternalClient.emit

Restituisce una matrice che elenca gli eventi per i quali l'emettitore ha registrato listener. I valori nella matrice sono stringhe o Symbols.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

Valori restituiti

Ereditato da InternalClient.eventNames

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

Per EventEmitters questo si comporta esattamente come chiamare .listeners l'emettitore.

Per EventTargets questo è l'unico modo per ottenere gli ascoltatori dell'evento per il target dell'evento. Questo è 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

Valori restituiti

Ereditato da InternalClient.getEventListeners

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

function getMaxListeners(): number

Valori restituiti

Ereditato da InternalClient.getMaxListeners

Restituisce il numero massimo di ascoltatori attualmente impostato.

Per EventEmitters questo si comporta esattamente come chiamare .getMaxListeners l'emettitore.

Per EventTargets questo è l'unico modo per ottenere il massimo ascolto di eventi per il target dell'evento. Se il numero di gestori di eventi su un singolo EventTarget supera il set massimo, l'EventTarget stamperà 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

Valori restituiti

Ereditato da InternalClient.getMaxListeners

function getTwin(): Promise<Twin>

Valori restituiti

ereditato da InternalClient.getTwin

function getTwin(done: Callback<Twin>)

Parametri

ereditato da InternalClient.getTwin

Un metodo di classe che restituisce il numero di ascoltatori per il dato eventName registrato sul dato 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

Valori restituiti

Ereditato da InternalClient.listenerCount

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

Valori restituiti

Ereditato da InternalClient.listenerCount

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

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

function listeners<K>(eventName: string | symbol): Function[]

Parametri

Valori restituiti

Ereditato da InternalClient.listener

Alias per emitter.removeListener().

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

Parametri

Valori restituiti

Ereditato da InternalClient.off

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

Ritorna e AsyncIterator che itera eventName gli eventi. Lancerà se emette EventEmitter'error'. Rimuove tutti gli ascoltatori quando esce dal loop. Il value ritorno di ogni iterazione è un array composto dagli argomenti dell'evento emesso.

An può essere usato per annullare l'attesa AbortSignal 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());

Usa l'opzione close per specificare un array di nomi di eventi che concluderanno 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

Valori restituiti

E AsyncIterator che itera eventName gli eventi emessi dal emitter

Ereditato da InternalClient.on

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

Parametri

Valori restituiti

Ereditato da InternalClient.on

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

Parametri

Valori restituiti

Ereditato da InternalClient.on

Crea un Promise che viene soddisfatto quando emette EventEmitter l'evento dato o che viene rifiutato se emette 'error'EventEmitter mentre è in attesa. Si Promise risolverà con una serie di tutti gli argomenti emessi all'evento dato.

Questo metodo è intenzionalmente generico e funziona con l'interfaccia della piattaforma web EventTarget , che non ha semantica degli 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 aspettare un altro evento. Se events.once() viene usato per attendere l'evento 'error' stesso, allora viene trattato 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

An può essere usato per annullare l'attesa AbortSignal 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

Valori restituiti

Ereditato da InternalClient.once

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

Parametri

Valori restituiti

Ereditato da InternalClient.once

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

Parametri

Valori restituiti

Ereditato da InternalClient.once

function open(): Promise<Connected>

Valori restituiti

Ereditato da InternalClient.open

function open(openCallback: Callback<Connected>)

Parametri

Ereditato da InternalClient.open

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

Parametri

Valori restituiti

Ereditato da InternalClient.prependListener

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

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

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

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

Parametri

Valori restituiti

Ereditato da InternalClient.prependOnceListener

Restituisce una copia della matrice di listener per l'evento denominato eventName, inclusi tutti i wrapper ( ad esempio quelli creati da .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

function rawListeners<K>(eventName: string | symbol): Function[]

Parametri

Valori restituiti

ereditato da InternalClient.rawListeners

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

Parametri

Valori restituiti

Ereditato da InternalClient.reject

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

Parametri

Ereditato da InternalClient.reject

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

Parametri

Valori restituiti

Ereditato da InternalClient.removeAllListeners

Rimuove il listener specificato dalla matrice di listener per l'evento denominato eventName.

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

removeListener() rimuoverà al massimo un'istanza di un listener dalla matrice del listener. Se un listener singolo è stato aggiunto più volte alla matrice di listener per il eventNamespecificato, removeListener() deve essere chiamato più volte per rimuovere ogni istanza.

Una volta generato un evento, tutti i listener collegati al listener al momento dell'emissione vengono chiamati in ordine. Ciò implica che qualsiasi o chiamate dopo l'emissione e l' prima che l'ultima esecuzione del listener non li rimuoverà dal in corso. Gli eventi successivi si comportano come previsto.

import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

Poiché i listener vengono gestiti usando una matrice interna, la chiamata di questo modificherà gli indici di posizione di qualsiasi listener registrato dopo la rimozione del listener. Ciò non influirà sull'ordine in cui vengono chiamati i listener, ma significa che tutte le copie della matrice del listener restituite dal metodo emitter.listeners() dovranno essere ricreate.

Quando una singola funzione è stata aggiunta più volte come gestore per un singolo evento (come nell'esempio seguente), removeListener() rimuoverà l'istanza aggiunta più di recente. Nell'esempio il listener once('ping') viene rimosso:

import { EventEmitter } from 'node:events';
const ee = new EventEmitter();

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

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

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

Parametri

Valori restituiti

Ereditato da InternalClient.removeListener

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

Parametri

Valori restituiti

ereditato da InternalClient.sendEvent

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

Parametri

ereditato da InternalClient.sendEvent

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

Parametri

Valori restituiti

ereditato da InternalClient.sendEventBatch

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

Parametri

ereditato da InternalClient.sendEventBatch

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

Parametri

Valori restituiti

Ereditato da InternalClient.setMaxListeners

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

Ereditato da InternalClient.setMaxListeners

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

function setRetryPolicy(policy: RetryPolicy)

Parametri

Ereditato da InternalClient.setRetryPolicy

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

Parametri

Valori restituiti

Ereditato da InternalClient.setTransportOptions

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

Parametri

Ereditato da InternalClient.setTransportOptions

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

Parametri

Ereditato da InternalClient.updateSharedAccessSignature

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

Parametri

Ereditato da InternalClient.__@captureRejectionSymbol@141