ModuleClient class

  • Référence
Paquet:
azure-iot-device

IoT Hub client d’appareil utilisé pour connecter un appareil à un hub Azure IoT.

Les utilisateurs du Kit de développement logiciel (SDK) doivent appeler l’une des méthodes de fabrique, fromConnectionString ou fromSharedAccessSignature pour créer un client d’appareil IoT Hub.

Extends

InternalClient

Propriétés héritées

captureRejections

Valeur : booléen

Modifiez l’option par défaut captureRejections sur tous les nouveaux EventEmitter objets.
captureRejectionSymbol

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

Découvrez comment écrire un personnalisé rejection handler.
defaultMaxListeners

Par défaut, un maximum d’écouteurs 10 peuvent être inscrits pour n’importe quel événement unique. Cette limite peut être modifiée pour des instances individuelles EventEmitter à l’aide de la emitter.setMaxListeners(n) méthode . Pour modifier la valeur par défaut pour toutes lesEventEmitter instances, la events.defaultMaxListenerspropriété peut être utilisée. Si cette valeur n’est pas un nombre positif, un RangeErrorest levée.

Soyez prudent lorsque vous définissez le events.defaultMaxListeners , car la modification affecte toutes lesEventEmitter instances, y compris celles créées avant la modification. Toutefois, l’appel emitter.setMaxListeners(n) est toujours prioritaire sur events.defaultMaxListeners.

Il ne s’agit pas d’une limite stricte. Le EventEmitter instance permet d’ajouter d’autres écouteurs, mais génère un avertissement de trace à stderr indiquant qu’une « fuite de mémoire EventEmitter » a été détectée. Pour n’importe quel seulEventEmitter, les emitter.getMaxListeners() méthodes et emitter.setMaxListeners()peuvent être utilisées pour éviter temporairement cet avertissement :

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));
});

L’indicateur --trace-warnings de ligne de commande peut être utilisé pour afficher la trace de pile pour de tels avertissements.

L’avertissement émis peut être inspecté avec process.on('warning') et aura les propriétés , typeet supplémentairesemitter, faisant count référence à l’émetteur d’événements instance, au nom de l’événement et au nombre d’écouteurs attachés, respectivement. Sa name propriété est définie sur 'MaxListenersExceededWarning'.
errorMonitor

Ce symbole doit être utilisé pour installer un écouteur uniquement pour les événements de surveillance 'error'. Les écouteurs installés à l’aide de ce symbole sont appelés avant l’appel des écouteurs standard'error' .

L’installation d’un écouteur à l’aide de ce symbole ne modifie pas le comportement une fois qu’un'error' événement est émis. Par conséquent, le processus se bloque toujours si aucun écouteur standard 'error' n’est installé.

Méthodes

close()
close(Callback<Disconnected>)

Ferme la connexion de transport et détruit les ressources clientes.

Remarque : Après avoir appelé cette méthode, l’objet ModuleClient ne peut pas être réutilisé.
fromAuthenticationProvider(AuthenticationProvider, any)

Crée un client de module IoT Hub à partir de la méthode d’authentification donnée et à l’aide du type de transport donné.
fromConnectionString(string, any)

Crée un client d’appareil IoT Hub à partir du chaîne de connexion donné à l’aide du type de transport donné.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)

Crée un client de module IoT Hub à l’aide des informations de configuration de l’environnement.

Si une variable d’environnement appelée EdgeHubConnectionString ou IotHubConnectionString existe, cette valeur est utilisée et le comportement est identique à l’appel fromConnectionString de cette variable. Si ces variables d’environnement n’existent pas, les variables suivantes DOIVENT être définies :

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

Crée un client de module IoT Hub à partir de la signature d’accès partagé donnée à l’aide du type de transport donné.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)

Appelle une méthode sur un appareil en aval ou sur un autre module sur le même appareil IoTEdge. Notez que cette fonctionnalité fonctionne uniquement lorsque le module est exécuté dans le cadre d’un appareil IoTEdge.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Inscrit un rappel pour une méthode nommée methodName.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Envoie un événement à la sortie du module donné
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Envoie un tableau d’événements à la sortie du module donné
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Transmet les options à l’objet ModuleClient qui peut être utilisé pour configurer le transport.

Méthodes héritées

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

Écoute une fois l’événement abort sur le fourni signal.

L’écoute de l’événement sur les abort signaux d’abandon est dangereuse et peut entraîner des fuites de ressources, car un autre tiers avec le signal peut appeler e.stopImmediatePropagation(). Malheureusement, Node.js ne pouvez pas changer cela, car cela violerait la norme web. En outre, l’API d’origine permet d’oublier facilement de supprimer des écouteurs.

Cette API permet d’utiliser AbortSignalen toute sécurité des dans Node.js API en résolvant ces deux problèmes en écoutant l’événement, ce qui stopImmediatePropagation n’empêche pas l’écouteur de s’exécuter.

Retourne un jetable afin qu’il puisse être désinscrit plus facilement.

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 pour emitter.on(eventName, listener).
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<K>(string | symbol, AnyRest)

Appelle de façon synchrone chacun des écouteurs inscrits pour l’événement nomméeventName, dans l’ordre dans lequel ils ont été inscrits, en passant les arguments fournis à chacun d’eux.

Retourne true si l’événement avait des écouteurs, false sinon.

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

Retourne un tableau répertoriant les événements pour lesquels l’émetteur a inscrit des écouteurs. Les valeurs du tableau sont des chaînes ou Symboldes s.

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> | _DOMEventTarget, string | symbol)

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName.

Pour EventEmitters, cela se comporte exactement comme appeler .listeners sur l’émetteur.

Pour EventTargets, il s’agit de la seule façon d’obtenir les écouteurs d’événements pour la cible d’événement. Cela est utile à des fins de débogage et de diagnostic.

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

Retourne la valeur d’écouteur maximale actuelle pour le EventEmitter qui est défini par emitter.setMaxListeners(n) ou par défaut sur defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)

Retourne la quantité maximale d’écouteurs actuellement définie.

Pour EventEmitters, cela se comporte exactement comme appeler .getMaxListeners sur l’émetteur.

Pour EventTargets, il s’agit de la seule façon d’obtenir le nombre maximal d’écouteurs d’événements pour la cible d’événement. Si le nombre de gestionnaires d’événements sur un seul EventTarget dépasse la valeur maximale définie, EventTarget affiche un avertissement.

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)

Méthode de classe qui retourne le nombre d’écouteurs pour le donné eventNameinscrit sur le donné 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)

Retourne le nombre d’écouteurs qui écoutent l’événement nommé eventName. Si listener est fourni, il retourne le nombre de fois où l’écouteur se trouve dans la liste des écouteurs de l’événement.
listeners<K>(string | symbol)

Retourne une copie du tableau d’écouteurs pour l’événement nommé 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 pour 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

Retourne un AsyncIterator qui itère les eventName événements. Elle lève si émet EventEmitter'error'. Il supprime tous les écouteurs lors de la sortie de la boucle. Le value retourné par chaque itération est un tableau composé des arguments d’événement émis.

Un AbortSignal peut être utilisé pour annuler l’attente d’événements :

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)

Ajoute la listener fonction à la fin du tableau d’écouteurs pour l’événement nommé eventName. Aucune vérification n’est effectuée pour voir si a listener déjà été ajouté. Plusieurs appels passant la même combinaison de eventNameet listener entraînent l’ajout et l’appel listener de plusieurs fois.

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

Retourne une référence à , afin que les EventEmitterappels puissent être chaînés.

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. Laemitter.prependListener() méthode peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

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)

Crée un Promise qui est rempli lorsque émet l’événement EventEmitter donné ou qui est rejeté si émet EventEmitter'error' pendant l’attente. Le Promise se résout avec un tableau de tous les arguments émis pour l’événement donné.

Cette méthode est intentionnellement générique et fonctionne avec l’interface EventTarget de plateforme web, qui n’a pas de sémantique d’événement spéciale'error' et n’écoute pas l’événement '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 gestion spéciale de l’événement 'error' est utilisée uniquement lorsque events.once()est utilisé pour attendre un autre événement. Si events.once() est utilisé pour attendre l’événement lui-mêmeerror' , il est traité comme tout autre type d’événement sans gestion spéciale :

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 peut être utilisé pour annuler l’attente de l’événement :

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

Ajoute une fonction à usage uniquelistener pour l’événement nommé eventName. La prochaine fois eventName qu’il est déclenché, cet écouteur est supprimé, puis appelé.

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

Retourne une référence à , afin que les EventEmitterappels puissent être chaînés.

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. Laemitter.prependOnceListener() méthode peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

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)

Ajoute la listener fonction au début du tableau d’écouteurs pour l’événement nommé eventName. Aucune vérification n’est effectuée pour voir si a listener déjà été ajouté. Plusieurs appels passant la même combinaison de eventNameet listener entraînent l’ajout et l’appel listener de plusieurs fois.

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

Retourne une référence à , afin que les EventEmitterappels puissent être chaînés.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Ajoute une fonction à usage uniquelistener pour l’événement nommé eventName au début du tableau d’écouteurs. La prochaine fois eventName qu’est déclenché, cet écouteur est supprimé, puis appelé.

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

Retourne une référence à , afin que les EventEmitterappels puissent être chaînés.
rawListeners<K>(string | symbol)

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName, y compris tous les wrappers (tels que ceux créés par .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)

Supprime tous les écouteurs ou ceux du spécifié eventName.

Il est mal pratique de supprimer les écouteurs ajoutés ailleurs dans le code, en particulier lorsque le EventEmitter instance a été créé par un autre composant ou module (par exemple, des sockets ou des flux de fichiers).

Retourne une référence à , EventEmitterafin que les appels puissent être chaînés.
removeListener<K>(string | symbol, (args: any[]) => void)

Supprime le spécifié listener du tableau d’écouteurs pour l’événement nomméeventName.

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

removeListener()supprime, au maximum, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le spécifié eventName, removeListener() il doit être appelé plusieurs fois pour supprimer chaque instance.

Une fois qu’un événement est émis, tous les écouteurs qui lui sont attachés au moment de l’émission sont appelés dans l’ordre. Cela implique que lesremoveListener() appels ou removeAllListeners()après l’émission et avant la fin de l’exécution du dernier écouteur ne les suppriment pas deemit() en cours. Les événements suivants se comportent comme prévu.

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

Étant donné que les écouteurs sont gérés à l’aide d’un tableau interne, l’appel de cela modifie les index de position de tout écouteur inscrit après la suppression de l’écouteur. Cela n’aura pas d’impact sur l’ordre dans lequel les écouteurs sont appelés, mais cela signifie que toutes les copies du tableau d’écouteurs retournées par la emitter.listeners() méthode devront être recréées.

Lorsqu’une fonction unique a été ajoutée en tant que gestionnaire plusieurs fois pour un seul événement (comme dans l’exemple ci-dessous), removeListener() supprime le instance le plus récemment ajouté. Dans l’exemple, l’écouteur once('ping')est supprimé :

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');

Retourne une référence à , EventEmitterafin que les appels puissent être chaînés.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

Par défaut EventEmitter, s affiche un avertissement si plusieurs 10 écouteurs sont ajoutés pour un événement particulier. Il s’agit d’une valeur par défaut utile qui permet de rechercher les fuites de mémoire. La emitter.setMaxListeners() méthode permet de modifier la limite pour ce instance spécifique EventEmitter . La valeur peut être définie surInfinity (ou 0) pour indiquer un nombre illimité d’écouteurs.

Retourne une référence à , EventEmitterafin que les appels puissent être chaînés.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | _DOMEventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

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

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

Définit la stratégie de nouvelle tentative utilisée par le client sur toutes les opérations. La valeur par défaut est ExponentielBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Détails de la propriété héritée

captureRejections

Valeur : booléen

Modifiez l’option par défaut captureRejections sur tous les nouveaux EventEmitter objets.

static captureRejections: boolean

Valeur de propriété

boolean

Hérité de InternalClient.captureRejections

captureRejectionSymbol

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

Découvrez comment écrire un personnalisé rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valeur de propriété

typeof captureRejectionSymbol

Hérité de InternalClient.captureRejectionSymbol

defaultMaxListeners

Par défaut, un maximum d’écouteurs 10 peuvent être inscrits pour n’importe quel événement unique. Cette limite peut être modifiée pour des instances individuelles EventEmitter à l’aide de la emitter.setMaxListeners(n) méthode . Pour modifier la valeur par défaut pour toutes lesEventEmitter instances, la events.defaultMaxListenerspropriété peut être utilisée. Si cette valeur n’est pas un nombre positif, un RangeErrorest levée.

Soyez prudent lorsque vous définissez le events.defaultMaxListeners , car la modification affecte toutes lesEventEmitter instances, y compris celles créées avant la modification. Toutefois, l’appel emitter.setMaxListeners(n) est toujours prioritaire sur events.defaultMaxListeners.

Il ne s’agit pas d’une limite stricte. Le EventEmitter instance permet d’ajouter d’autres écouteurs, mais génère un avertissement de trace à stderr indiquant qu’une « fuite de mémoire EventEmitter » a été détectée. Pour n’importe quel seulEventEmitter, les emitter.getMaxListeners() méthodes et emitter.setMaxListeners()peuvent être utilisées pour éviter temporairement cet avertissement :

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));
});

L’indicateur --trace-warnings de ligne de commande peut être utilisé pour afficher la trace de pile pour de tels avertissements.

L’avertissement émis peut être inspecté avec process.on('warning') et aura les propriétés , typeet supplémentairesemitter, faisant count référence à l’émetteur d’événements instance, au nom de l’événement et au nombre d’écouteurs attachés, respectivement. Sa name propriété est définie sur 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valeur de propriété

number

Hérité de InternalClient.defaultMaxListeners

errorMonitor

Ce symbole doit être utilisé pour installer un écouteur uniquement pour les événements de surveillance 'error'. Les écouteurs installés à l’aide de ce symbole sont appelés avant l’appel des écouteurs standard'error' .

L’installation d’un écouteur à l’aide de ce symbole ne modifie pas le comportement une fois qu’un'error' événement est émis. Par conséquent, le processus se bloque toujours si aucun écouteur standard 'error' n’est installé.

static errorMonitor: typeof errorMonitor

Valeur de propriété

typeof errorMonitor

Hérité de InternalClient.errorMonitor

Détails de la méthode

close() 

function close(): Promise<Disconnected>

Retours

Promise<Disconnected>

close(Callback<Disconnected>)

Ferme la connexion de transport et détruit les ressources clientes.

Remarque : Après avoir appelé cette méthode, l’objet ModuleClient ne peut pas être réutilisé.

function close(closeCallback?: Callback<Disconnected>)

Paramètres

closeCallback

Callback<Disconnected>

Fonction facultative à appeler une fois le transport déconnecté et le client fermé.

fromAuthenticationProvider(AuthenticationProvider, any)

Crée un client de module IoT Hub à partir de la méthode d’authentification donnée et à l’aide du type de transport donné.

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

Paramètres

authenticationProvider

AuthenticationProvider

Objet utilisé pour obtenir les paramètres d’authentification pour le hub IoT.

transportCtor

any

Protocole de transport utilisé pour se connecter à IoT Hub.

Retours

ModuleClient

fromConnectionString(string, any)

Crée un client d’appareil IoT Hub à partir du chaîne de connexion donné à l’aide du type de transport donné.

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

Paramètres

connStr

string

Une chaîne de connexion qui encapsule les autorisations de « connexion d’appareil » sur un hub IoT.

transportCtor

any

Constructeur de transport.

Retours

ModuleClient

fromEnvironment(any) 

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

Paramètres

transportCtor

any

Retours

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Crée un client de module IoT Hub à l’aide des informations de configuration de l’environnement.

Si une variable d’environnement appelée EdgeHubConnectionString ou IotHubConnectionString existe, cette valeur est utilisée et le comportement est identique à l’appel fromConnectionString de cette variable. Si ces variables d’environnement n’existent pas, les variables suivantes DOIVENT être définies :

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

Paramètres

transportCtor

any

Protocole de transport utilisé pour se connecter à IoT Hub.

callback

Callback<ModuleClient>

Rappel facultatif à appeler lorsque le ModuleClient a été construit ou si une erreur se produit lors de la création du client.

fromSharedAccessSignature(string, any)

Crée un client de module IoT Hub à partir de la signature d’accès partagé donnée à l’aide du type de transport donné.

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

Paramètres

sharedAccessSignature

string

Signature d’accès partagé qui encapsule les autorisations de « connexion d’appareil » sur un hub IoT.

transportCtor

any

Retours

ModuleClient

invokeMethod(string, MethodParams) 

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

Paramètres

deviceId

string

methodParams

MethodParams

Retours

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Appelle une méthode sur un appareil en aval ou sur un autre module sur le même appareil IoTEdge. Notez que cette fonctionnalité fonctionne uniquement lorsque le module est exécuté dans le cadre d’un appareil IoTEdge.

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

Paramètres

deviceId

string

identificateur de l’appareil cible

methodParams

MethodParams

paramètres de l’appel de méthode directe

callback

Callback<MethodResult>

rappel facultatif qui sera appelé avec un objet Error ou le résultat de l’appel de méthode.

invokeMethod(string, string, MethodParams) 

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

Paramètres

deviceId

string

moduleId

string

methodParams

MethodParams

Retours

Promise<MethodResult>

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

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

Paramètres

deviceId

string

moduleId

string

methodParams

MethodParams

callback

Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Inscrit un rappel pour une méthode nommée methodName.

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

Paramètres

methodName

string

Nom de la méthode qui sera gérée par le rappel

callback

DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

Fonction qui doit être appelée chaque fois qu’une demande de méthode pour la méthode appelée methodName est reçue.

sendOutputEvent(string, Message) 

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

Paramètres

outputName

string

message
Message

Retours

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Envoie un événement à la sortie du module donné

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

Paramètres

outputName

string

Nom de la sortie à laquelle envoyer l’événement

message
Message

Message à envoyer à la sortie donnée

callback

Callback<MessageEnqueued>

Fonction facultative à appeler lorsque l’opération a été mise en file d’attente.

sendOutputEventBatch(string, Message[]) 

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

Paramètres

outputName

string

messages

Message[]

Retours

Promise<MessageEnqueued>

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

Envoie un tableau d’événements à la sortie du module donné

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

Paramètres

outputName

string

Nom de la sortie à laquelle envoyer les événements

messages

Message[]

callback

Callback<MessageEnqueued>

Fonction à appeler lorsque les opérations ont été mises en file d’attente.

setOptions(DeviceClientOptions) 

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

Paramètres

options
DeviceClientOptions

Retours

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Transmet les options à l’objet ModuleClient qui peut être utilisé pour configurer le transport.

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

Paramètres

options
DeviceClientOptions

Objet DeviceClientOptions .

done

Callback<TransportConfigured>

Rappel facultatif à appeler une fois les options définies.

Détails de la méthode héritée

abandon(Message) 

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

Paramètres

message
Message

Retours

Promise<MessageAbandoned>

Hérité de InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>) 

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

Paramètres

message
Message
abandonCallback

Callback<MessageAbandoned>

Hérité de InternalClient.abandon

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

Écoute une fois l’événement abort sur le fourni signal.

L’écoute de l’événement sur les abort signaux d’abandon est dangereuse et peut entraîner des fuites de ressources, car un autre tiers avec le signal peut appeler e.stopImmediatePropagation(). Malheureusement, Node.js ne pouvez pas changer cela, car cela violerait la norme web. En outre, l’API d’origine permet d’oublier facilement de supprimer des écouteurs.

Cette API permet d’utiliser AbortSignalen toute sécurité des dans Node.js API en résolvant ces deux problèmes en écoutant l’événement, ce qui stopImmediatePropagation n’empêche pas l’écouteur de s’exécuter.

Retourne un jetable afin qu’il puisse être désinscrit plus facilement.

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

Paramètres

signal

AbortSignal

resource

(event: Event) => void

Retours

Disposable

Jetable qui supprime l’écouteur abort .

Hérité de InternalClient.addAbortListener

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

Alias pour emitter.on(eventName, listener).

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

Paramètres

eventName

string | symbol

listener

(args: any[]) => void

Retours

ModuleClient

Hérité de InternalClient.addListener

complete(Message) 

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

Paramètres

message
Message

Retours

Promise<MessageCompleted>

Hérité de InternalClient.complete

complete(Message, Callback<MessageCompleted>) 

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

Paramètres

message
Message
completeCallback

Callback<MessageCompleted>

Hérité de InternalClient.complete

emit<K>(string | symbol, AnyRest)

Appelle de façon synchrone chacun des écouteurs inscrits pour l’événement nomméeventName, dans l’ordre dans lequel ils ont été inscrits, en passant les arguments fournis à chacun d’eux.

Retourne true si l’événement avait des écouteurs, false sinon.

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

Paramètres

eventName

string | symbol

args

AnyRest

Retours

boolean

Hérité de InternalClient.emit

eventNames()

Retourne un tableau répertoriant les événements pour lesquels l’émetteur a inscrit des écouteurs. Les valeurs du tableau sont des chaînes ou Symboldes s.

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)[]

Retours

(string | symbol)[]

Hérité de InternalClient.eventNames

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

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName.

Pour EventEmitters, cela se comporte exactement comme appeler .listeners sur l’émetteur.

Pour EventTargets, il s’agit de la seule façon d’obtenir les écouteurs d’événements pour la cible d’événement. Cela est utile à des fins de débogage et de diagnostic.

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> | _DOMEventTarget, name: string | symbol): Function[]

Paramètres

emitter

EventEmitter<DefaultEventMap> | _DOMEventTarget

name

string | symbol

Retours

Function[]

Hérité de InternalClient.getEventListeners

getMaxListeners()

Retourne la valeur d’écouteur maximale actuelle pour le EventEmitter qui est défini par emitter.setMaxListeners(n) ou par défaut sur defaultMaxListeners.

function getMaxListeners(): number

Retours

number

Hérité de InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | _DOMEventTarget)

Retourne la quantité maximale d’écouteurs actuellement définie.

Pour EventEmitters, cela se comporte exactement comme appeler .getMaxListeners sur l’émetteur.

Pour EventTargets, il s’agit de la seule façon d’obtenir le nombre maximal d’écouteurs d’événements pour la cible d’événement. Si le nombre de gestionnaires d’événements sur un seul EventTarget dépasse la valeur maximale définie, EventTarget affiche un avertissement.

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> | _DOMEventTarget): number

Paramètres

emitter

EventEmitter<DefaultEventMap> | _DOMEventTarget

Retours

number

Hérité de InternalClient.getMaxListeners

getTwin() 

function getTwin(): Promise<Twin>

Retours

Promise<Twin>

Hérité de InternalClient.getTwin

getTwin(Callback<Twin>) 

function getTwin(done: Callback<Twin>)

Paramètres

done

Callback<Twin>

Hérité de InternalClient.getTwin

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Avertissement

Cette API est à présent déconseillée.

Since v3.2.0 - Use listenerCount instead.

Méthode de classe qui retourne le nombre d’écouteurs pour le donné eventNameinscrit sur le donné 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

Paramètres

emitter

EventEmitter<DefaultEventMap>

Émetteur à interroger

eventName

string | symbol

Nom de l’événement

Retours

number

Hérité de InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

Retourne le nombre d’écouteurs qui écoutent l’événement nommé eventName. Si listener est fourni, il retourne le nombre de fois où l’écouteur se trouve dans la liste des écouteurs de l’événement.

function listenerCount<K>(eventName: string | symbol, listener?: Function): number

Paramètres

eventName

string | symbol

Nom de l’événement écouté

listener

Function

Fonction de gestionnaire d’événements

Retours

number

Hérité de InternalClient.listenerCount

listeners<K>(string | symbol)

Retourne une copie du tableau d’écouteurs pour l’événement nommé 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[]

Paramètres

eventName

string | symbol

Retours

Function[]

Hérité de InternalClient.listeners

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

Alias pour emitter.removeListener().

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

Paramètres

eventName

string | symbol

listener

(args: any[]) => void

Retours

ModuleClient

Hérité de InternalClient.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

Retourne un AsyncIterator qui itère les eventName événements. Elle lève si émet EventEmitter'error'. Il supprime tous les écouteurs lors de la sortie de la boucle. Le value retourné par chaque itération est un tableau composé des arguments d’événement émis.

Un AbortSignal peut être utilisé pour annuler l’attente d’événements :

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>

Paramètres

emitter

EventEmitter<DefaultEventMap>

eventName

string

Nom de l’événement écouté

options

StaticEventEmitterOptions

Retours

AsyncIterableIterator<any>

qui itère les eventName événements émis par le emitter

Hérité de InternalClient.on

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

Ajoute la listener fonction à la fin du tableau d’écouteurs pour l’événement nommé eventName. Aucune vérification n’est effectuée pour voir si a listener déjà été ajouté. Plusieurs appels passant la même combinaison de eventNameet listener entraînent l’ajout et l’appel listener de plusieurs fois.

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

Retourne une référence à , afin que les EventEmitterappels puissent être chaînés.

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. Laemitter.prependListener() méthode peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

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

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retours

ModuleClient

Hérité de InternalClient.on

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

Crée un Promise qui est rempli lorsque émet l’événement EventEmitter donné ou qui est rejeté si émet EventEmitter'error' pendant l’attente. Le Promise se résout avec un tableau de tous les arguments émis pour l’événement donné.

Cette méthode est intentionnellement générique et fonctionne avec l’interface EventTarget de plateforme web, qui n’a pas de sémantique d’événement spéciale'error' et n’écoute pas l’événement '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 gestion spéciale de l’événement 'error' est utilisée uniquement lorsque events.once()est utilisé pour attendre un autre événement. Si events.once() est utilisé pour attendre l’événement lui-mêmeerror' , il est traité comme tout autre type d’événement sans gestion spéciale :

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 peut être utilisé pour annuler l’attente de l’événement :

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[]>

Paramètres

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

Retours

Promise<any[]>

Hérité de InternalClient.once

once(_DOMEventTarget, string, StaticEventEmitterOptions) 

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

Paramètres

emitter

_DOMEventTarget

eventName

string

options

StaticEventEmitterOptions

Retours

Promise<any[]>

Hérité de InternalClient.once

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

Ajoute une fonction à usage uniquelistener pour l’événement nommé eventName. La prochaine fois eventName qu’il est déclenché, cet écouteur est supprimé, puis appelé.

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

Retourne une référence à , afin que les EventEmitterappels puissent être chaînés.

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. Laemitter.prependOnceListener() méthode peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

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

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retours

ModuleClient

Hérité de InternalClient.once

open() 

function open(): Promise<Connected>

Retours

Promise<Connected>

Hérité de InternalClient.open

open(Callback<Connected>) 

function open(openCallback: Callback<Connected>)

Paramètres

openCallback

Callback<Connected>

Hérité de InternalClient.open

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

Ajoute la listener fonction au début du tableau d’écouteurs pour l’événement nommé eventName. Aucune vérification n’est effectuée pour voir si a listener déjà été ajouté. Plusieurs appels passant la même combinaison de eventNameet listener entraînent l’ajout et l’appel listener de plusieurs fois.

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

Retourne une référence à , afin que les EventEmitterappels puissent être chaînés.

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

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retours

ModuleClient

Hérité de InternalClient.prependListener

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

Ajoute une fonction à usage uniquelistener pour l’événement nommé eventName au début du tableau d’écouteurs. La prochaine fois eventName qu’est déclenché, cet écouteur est supprimé, puis appelé.

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

Retourne une référence à , afin que les EventEmitterappels puissent être chaînés.

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

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retours

ModuleClient

Hérité de InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName, y compris tous les wrappers (tels que ceux créés par .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[]

Paramètres

eventName

string | symbol

Retours

Function[]

Hérité de InternalClient.rawListeners

reject(Message) 

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

Paramètres

message
Message

Retours

Promise<MessageRejected>

Hérité de InternalClient.reject

reject(Message, Callback<MessageRejected>) 

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

Paramètres

message
Message
rejectCallback

Callback<MessageRejected>

Hérité de InternalClient.reject

removeAllListeners(string | symbol)

Supprime tous les écouteurs ou ceux du spécifié eventName.

Il est mal pratique de supprimer les écouteurs ajoutés ailleurs dans le code, en particulier lorsque le EventEmitter instance a été créé par un autre composant ou module (par exemple, des sockets ou des flux de fichiers).

Retourne une référence à , EventEmitterafin que les appels puissent être chaînés.

function removeAllListeners(eventName?: string | symbol): ModuleClient

Paramètres

eventName

string | symbol

Retours

ModuleClient

Hérité de InternalClient.removeAllListeners

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

Supprime le spécifié listener du tableau d’écouteurs pour l’événement nomméeventName.

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

removeListener()supprime, au maximum, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le spécifié eventName, removeListener() il doit être appelé plusieurs fois pour supprimer chaque instance.

Une fois qu’un événement est émis, tous les écouteurs qui lui sont attachés au moment de l’émission sont appelés dans l’ordre. Cela implique que lesremoveListener() appels ou removeAllListeners()après l’émission et avant la fin de l’exécution du dernier écouteur ne les suppriment pas deemit() en cours. Les événements suivants se comportent comme prévu.

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

Étant donné que les écouteurs sont gérés à l’aide d’un tableau interne, l’appel de cela modifie les index de position de tout écouteur inscrit après la suppression de l’écouteur. Cela n’aura pas d’impact sur l’ordre dans lequel les écouteurs sont appelés, mais cela signifie que toutes les copies du tableau d’écouteurs retournées par la emitter.listeners() méthode devront être recréées.

Lorsqu’une fonction unique a été ajoutée en tant que gestionnaire plusieurs fois pour un seul événement (comme dans l’exemple ci-dessous), removeListener() supprime le instance le plus récemment ajouté. Dans l’exemple, l’écouteur once('ping')est supprimé :

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');

Retourne une référence à , EventEmitterafin que les appels puissent être chaînés.

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

Paramètres

eventName

string | symbol

listener

(args: any[]) => void

Retours

ModuleClient

Hérité de InternalClient.removeListener

sendEvent(Message) 

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

Paramètres

message
Message

Retours

Promise<MessageEnqueued>

Hérité de InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>) 

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

Paramètres

message
Message
sendEventCallback

Callback<MessageEnqueued>

Hérité de InternalClient.sendEvent

sendEventBatch(Message[]) 

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

Paramètres

messages

Message[]

Retours

Promise<MessageEnqueued>

Hérité de InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>) 

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

Paramètres

messages

Message[]

sendEventBatchCallback

Callback<MessageEnqueued>

Hérité de InternalClient.sendEventBatch

setMaxListeners(number)

Par défaut EventEmitter, s affiche un avertissement si plusieurs 10 écouteurs sont ajoutés pour un événement particulier. Il s’agit d’une valeur par défaut utile qui permet de rechercher les fuites de mémoire. La emitter.setMaxListeners() méthode permet de modifier la limite pour ce instance spécifique EventEmitter . La valeur peut être définie surInfinity (ou 0) pour indiquer un nombre illimité d’écouteurs.

Retourne une référence à , EventEmitterafin que les appels puissent être chaînés.

function setMaxListeners(n: number): ModuleClient

Paramètres

n

number

Retours

ModuleClient

Hérité de InternalClient.setMaxListeners

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

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> | _DOMEventTarget)[])

Paramètres

n

number

Nombre non négatif. Nombre maximal d’écouteurs par EventTarget événement.

eventTargets

(EventEmitter<DefaultEventMap> | _DOMEventTarget)[]

Hérité de InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Définit la stratégie de nouvelle tentative utilisée par le client sur toutes les opérations. La valeur par défaut est ExponentielBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Paramètres

policy

RetryPolicy

{RetryPolicy} Stratégie de nouvelle tentative qui doit être utilisée pour toutes les opérations futures.

Hérité de InternalClient.setRetryPolicy

setTransportOptions(any) 

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

Paramètres

options

any

Retours

Promise<TransportConfigured>

Hérité de InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>) 

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

Paramètres

options

any

done

Callback<TransportConfigured>

Hérité de InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>) 

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

Paramètres

sharedAccessSignature

string

updateSasCallback

Callback<SharedAccessSignatureUpdated>

Hérité de InternalClient.updateSharedAccessSignature

[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest) 

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

Paramètres

error

Error

event

string | symbol

args

AnyRest

Hérité de InternalClient.__@captureRejectionSymbol@138