Partager via

Client class

Colis:
azure-iothub

Le client de service IoT Hub est utilisé pour communiquer avec les appareils via un hub Azure IoT. Il permet à l’utilisateur du Kit de développement logiciel (SDK) :

  • envoyer des commandes cloud-à-appareil (également appelées commandes) aux appareils : les commandes sont mises en file d’attente sur IoT Hub et remises de manière asynchrone uniquement lorsque l’appareil est connecté. Seules 50 commandes peuvent être mises en file d’attente par appareil.
  • appeler des méthodes directes sur des appareils (qui fonctionnent uniquement si l’appareil est actuellement connecté : il s’agit d’un moyen synchrone de communiquer avec l’appareil)
  • écoutez les messages de commentaires envoyés par les appareils pour les commandes précédentes.
  • écoutez les notifications de chargement de fichiers à partir d’appareils.

Les utilisateurs doivent créer de nouvelles instances Client en appelant l’une des méthodes de fabrique, fromConnectionString ou à partir deSharedAccessSignature, pour créer un client de service IoT Hub.

S' étend

EventEmitter

Méthode

close()
close(IncomingMessageCallback<Disconnected>)

Ferme la connexion à un hub IoT.
fromConnectionString(string, TransportCtor)

Crée un client de service IoT Hub à partir de la chaîne de connexion donnée à l’aide du transport par défaut (Amqp) ou de celui spécifié dans le deuxième argument.
fromSharedAccessSignature(string, TransportCtor)

Crée un client de service IoT Hub à partir de la signature d’accès partagé donnée à l’aide du transport par défaut (Amqp) ou de celui spécifié dans le deuxième argument.
fromTokenCredential(string, TokenCredential, TransportCtor)

Crée un client de service IoT Hub à partir du jeton AzureCredential donné à l’aide du transport par défaut (Amqp) ou de celui spécifié dans le deuxième argument.
getFeedbackReceiver()
getFeedbackReceiver(IncomingMessageCallback<ServiceReceiver>)

Retourne un objet AmqpReceiver qui émet des événements lorsque de nouveaux messages de commentaires sont reçus par le client.
getFileNotificationReceiver()
getFileNotificationReceiver(IncomingMessageCallback<ServiceReceiver>)

Retourne un objet AmqpReceiver qui émet des événements lorsque de nouvelles notifications de chargement de fichier sont reçues par le client.
invokeDeviceMethod(string, DeviceMethodParams)
invokeDeviceMethod(string, DeviceMethodParams, IncomingMessageCallback<any>)

Appelle une méthode sur un appareil ou un module particulier.
invokeDeviceMethod(string, string, DeviceMethodParams)
invokeDeviceMethod(string, string, DeviceMethodParams, IncomingMessageCallback<any>)
open()
open(IncomingMessageCallback<Connected>)

Ouvre la connexion à un hub IoT.
send(string, Message | BufferConvertible)
send(string, Message | BufferConvertible, IncomingMessageCallback<MessageEnqueued>)

Envoie un message à un appareil.
setRetryPolicy(RetryPolicy)

Définissez la stratégie utilisée par le client pour réessayer les opérations réseau.

Méthodes héritées

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

Alias pour emitter.on(eventName, listener).
emit<E>(string | symbol, any[])

Appelle de manière 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 enregistré des écouteurs.

import { EventEmitter } from 'node:events';

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

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

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

Retourne la valeur maximale actuelle de l’écouteur pour l'EventEmitter qui est définie par emitter.setMaxListeners(n) ou par défaut sur events.defaultMaxListeners.
listenerCount<E>(string | symbol, (args: any[]) => void)

Retourne le nombre d’écouteurs à l’écoute de l’événement nommé eventName. Si listener est fourni, il retourne le nombre de fois où l’écouteur est trouvé dans la liste des écouteurs de l’événement.
listeners<E>(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<E>(string | symbol, (args: any[]) => void)

Alias pour emitter.removeListener().
on<E>(string | symbol, (args: any[]) => void)

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

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

Retourne une référence au EventEmitter, afin que les appels 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. La méthode emitter.prependListener() 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<E>(string | symbol, (args: any[]) => void)

Ajoute une fonction listener unique pour l’événement nommé eventName. La prochaine fois que eventName est déclenchée, cet écouteur est supprimé, puis appelé.

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

Retourne une référence au EventEmitter, afin que les appels 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. La méthode emitter.prependOnceListener() 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
prependListener<E>(string | symbol, (args: any[]) => void)

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

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

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

Ajoute une fonction listener unique pour l’événement nommé eventName au début du tableau d’écouteurs. La prochaine fois que eventName est déclenchée, cet écouteur est supprimé, puis appelé.

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

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.
rawListeners<E>(string | symbol)

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName, y compris 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');
removeAllListeners<E>(string | symbol)

Supprime tous les écouteurs, ou ceux de la eventNamespécifiée.

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

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

Supprime le listener spécifié 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() supprimera, au plus, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le eventNamespécifié, removeListener() doit être appelé plusieurs fois pour supprimer chaque instance.

Une fois qu’un événement est émis, tous les écouteurs attachés à celui-ci au moment de l’émission sont appelés dans l’ordre. Cela implique que tout removeListener() appel removeAllListeners()après émission et avant la fin de l’exécution du dernier auditeur ne les emit() supprimera pas de la procédure 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

Comme les auditeurs sont gérés via un tableau interne, appeler cela modifie les indices de position de tout auditeur enregistré après la suppression de cet auditeur. 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 méthode emitter.listeners() devront être recréées.

Lorsqu’une fonction unique a été ajoutée en tant que gestionnaire plusieurs fois pour un événement unique (comme dans l’exemple ci-dessous), removeListener() supprime l’instance la plus récemment ajoutée. 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 au EventEmitter, afin que les appels puissent être chaînés.
setMaxListeners(number)

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

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.
[captureRejectionSymbol](Error, string | symbol, any[])

La Symbol.for('nodejs.rejection') méthode est appelée au cas où un rejet de promesse survient lors de l’émission d’un événement et captureRejections est activée sur l’émetteur. Il est possible d’utiliser events.captureRejectionSymbol à la place de Symbol.for('nodejs.rejection').

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

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

Détails de la méthode

close() 

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

Retourne

Promise<ResultWithIncomingMessage<Disconnected>>

close(IncomingMessageCallback<Disconnected>)

Ferme la connexion à un hub IoT.

function close(done?: IncomingMessageCallback<Disconnected>)

Paramètres

done

IncomingMessageCallback<Disconnected>

Fonction facultative à appeler lorsque l’opération est terminée. done sera passé un argument d’objet Error, qui sera null si l’opération s’est terminée avec succès.

fromConnectionString(string, TransportCtor)

Crée un client de service IoT Hub à partir de la chaîne de connexion donnée à l’aide du transport par défaut (Amqp) ou de celui spécifié dans le deuxième argument.

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

Paramètres

connStr

string

Chaîne de connexion qui encapsule les autorisations « device connect » sur un hub IoT.

transportCtor
TransportCtor

Retourne

Client

fromSharedAccessSignature(string, TransportCtor)

Crée un client de service IoT Hub à partir de la signature d’accès partagé donnée à l’aide du transport par défaut (Amqp) ou de celui spécifié dans le deuxième argument.

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

Paramètres

sharedAccessSignature

string

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

transportCtor
TransportCtor

Retourne

Client

fromTokenCredential(string, TokenCredential, TransportCtor)

Crée un client de service IoT Hub à partir du jeton AzureCredential donné à l’aide du transport par défaut (Amqp) ou de celui spécifié dans le deuxième argument.

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

Paramètres

hostName

string

Nom d’hôte du service Azure.

tokenCredential
TokenCredential

Azure TokenCredential utilisé pour s’authentifier auprès du service Azure

transportCtor
TransportCtor

Retourne

Client

getFeedbackReceiver() 

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

Retourne

Promise<ResultWithIncomingMessage<ServiceReceiver>>

getFeedbackReceiver(IncomingMessageCallback<ServiceReceiver>)

Retourne un objet AmqpReceiver qui émet des événements lorsque de nouveaux messages de commentaires sont reçus par le client.

function getFeedbackReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Paramètres

done

IncomingMessageCallback<ServiceReceiver>

Fonction facultative à appeler lorsque l’opération est terminée. done sera appelée avec deux arguments : un objet Error (peut être null) et un objet AmqpReceiver.

getFileNotificationReceiver() 

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

Retourne

Promise<ResultWithIncomingMessage<ServiceReceiver>>

getFileNotificationReceiver(IncomingMessageCallback<ServiceReceiver>)

Retourne un objet AmqpReceiver qui émet des événements lorsque de nouvelles notifications de chargement de fichier sont reçues par le client.

function getFileNotificationReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Paramètres

done

IncomingMessageCallback<ServiceReceiver>

Fonction facultative à appeler lorsque l’opération est terminée. done sera appelée avec deux arguments : un objet Error (peut être null) et un objet AmqpReceiver.

invokeDeviceMethod(string, DeviceMethodParams) 

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

Paramètres

deviceId

string

methodParams
DeviceMethodParams

Retourne

Promise<ResultWithIncomingMessage<any>>

invokeDeviceMethod(string, DeviceMethodParams, IncomingMessageCallback<any>)

Appelle une méthode sur un appareil ou un module particulier.

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

Paramètres

deviceId

string

Identificateur d’une identité d’appareil existante.

methodParams
DeviceMethodParams
done

IncomingMessageCallback<any>

Rappel facultatif à appeler avec le résultat de l’exécution de la méthode.

invokeDeviceMethod(string, string, DeviceMethodParams) 

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

Paramètres

deviceId

string

moduleId

string

methodParams
DeviceMethodParams

Retourne

Promise<ResultWithIncomingMessage<any>>

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

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

Paramètres

deviceId

string

moduleId

string

methodParams
DeviceMethodParams
done

IncomingMessageCallback<any>

open() 

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

Retourne

Promise<ResultWithIncomingMessage<Connected>>

open(IncomingMessageCallback<Connected>)

Ouvre la connexion à un hub IoT.

function open(done?: IncomingMessageCallback<Connected>)

Paramètres

done

IncomingMessageCallback<Connected>

Fonction facultative à appeler lorsque l’opération est terminée. done sera passé un argument d’objet Error, qui sera null si l’opération s’est terminée avec succès.

send(string, Message | BufferConvertible) 

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

Paramètres

deviceId

string

message

Message | BufferConvertible

Retourne

Promise<ResultWithIncomingMessage<MessageEnqueued>>

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

Envoie un message à un appareil.

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

Paramètres

deviceId

string

Identificateur d’une identité d’appareil existante.

message

Message | BufferConvertible

Corps du message à envoyer à l’appareil. Si message n’est pas de type Message, il est converti.

done

IncomingMessageCallback<MessageEnqueued>

Fonction facultative à appeler lorsque l’opération est terminée. done sera appelée avec deux arguments : un objet Error (peut être null) et un objet réponse spécifique au transport utile pour la journalisation ou le débogage.

setRetryPolicy(RetryPolicy)

Définissez la stratégie utilisée par le client pour réessayer les opérations réseau.

function setRetryPolicy(policy: RetryPolicy)

Paramètres

policy

RetryPolicy

stratégie utilisée pour réessayer les opérations (par exemple, ouvrir, envoyer, etc.). Le SDK est fourni avec 2 stratégies intégrées : ExponentialBackoffWithJitter (valeur par défaut) et NoRetry (pour annuler toute forme de nouvelle tentative). L’utilisateur peut également transmettre son propre objet tant qu’il implémente 2 méthodes : - shouldRetry(err : Error) : booléen : indique si une opération doit être retentée en fonction du type d’erreur - nextRetryTimeout(retryCount : number, throttled : boolean) : nombre : retourne le temps d’attente (en millisecondes) avant de réessayer en fonction du nombre de tentatives précédent (retryCount) et du fait que l’erreur est une erreur de limitation ou non.

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

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

Alias pour emitter.on(eventName, listener).

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

Paramètres

eventName

string | symbol

listener

(args: any[]) => void

Retourne

Client

héritée de EventEmitter.addListener

emit<E>(string | symbol, any[])

Appelle de manière 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<E>(eventName: string | symbol, args: any[]): boolean

Paramètres

eventName

string | symbol

args

any[]

Retourne

boolean

héritée de EventEmitter.emit

eventNames()

Retourne un tableau répertoriant les événements pour lesquels l’émetteur a enregistré des écouteurs.

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

Retourne

(string | symbol)[]

héritée de EventEmitter.eventNames

getMaxListeners()

Retourne la valeur maximale actuelle de l’écouteur pour l'EventEmitter qui est définie par emitter.setMaxListeners(n) ou par défaut sur events.defaultMaxListeners.

function getMaxListeners(): number

Retourne

number

héritée de EventEmitter.getMaxListeners

listenerCount<E>(string | symbol, (args: any[]) => void)

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

function listenerCount<E>(eventName: string | symbol, listener?: (args: any[]) => void): number

Paramètres

eventName

string | symbol

Nom de l’événement en cours d’écoute

listener

(args: any[]) => void

Fonction du gestionnaire d’événements

Retourne

number

héritée de EventEmitter.listenerCount

listeners<E>(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<E>(eventName: string | symbol): (args: any[]) => void[]

Paramètres

eventName

string | symbol

Retourne

(args: any[]) => void[]

héritée de EventEmitter.listeners

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

Alias pour emitter.removeListener().

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

Paramètres

eventName

string | symbol

listener

(args: any[]) => void

Retourne

Client

héritée de EventEmitter.off

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

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

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

Retourne une référence au EventEmitter, afin que les appels 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. La méthode emitter.prependListener() 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<E>(eventName: string | symbol, listener: (args: any[]) => void): Client

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retourne

Client

héritée de EventEmitter.on

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

Ajoute une fonction listener unique pour l’événement nommé eventName. La prochaine fois que eventName est déclenchée, cet écouteur est supprimé, puis appelé.

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

Retourne une référence au EventEmitter, afin que les appels 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. La méthode emitter.prependOnceListener() 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<E>(eventName: string | symbol, listener: (args: any[]) => void): Client

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retourne

Client

héritée de EventEmitter.once

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

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

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

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

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

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retourne

Client

héritée de EventEmitter.prependListener

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

Ajoute une fonction listener unique pour l’événement nommé eventName au début du tableau d’écouteurs. La prochaine fois que eventName est déclenchée, cet écouteur est supprimé, puis appelé.

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

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

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

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retourne

Client

héritée de EventEmitter.prependOnceListener

rawListeners<E>(string | symbol)

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName, y compris 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<E>(eventName: string | symbol): (args: any[]) => void[]

Paramètres

eventName

string | symbol

Retourne

(args: any[]) => void[]

héritée de EventEmitter.rawListeners

removeAllListeners<E>(string | symbol)

Supprime tous les écouteurs, ou ceux de la eventNamespécifiée.

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

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

function removeAllListeners<E>(eventName?: string | symbol): Client

Paramètres

eventName

string | symbol

Retourne

Client

héritée de EventEmitter.removeAllListeners

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

Supprime le listener spécifié 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() supprimera, au plus, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le eventNamespécifié, removeListener() doit être appelé plusieurs fois pour supprimer chaque instance.

Une fois qu’un événement est émis, tous les écouteurs attachés à celui-ci au moment de l’émission sont appelés dans l’ordre. Cela implique que tout removeListener() appel removeAllListeners()après émission et avant la fin de l’exécution du dernier auditeur ne les emit() supprimera pas de la procédure 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

Comme les auditeurs sont gérés via un tableau interne, appeler cela modifie les indices de position de tout auditeur enregistré après la suppression de cet auditeur. 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 méthode emitter.listeners() devront être recréées.

Lorsqu’une fonction unique a été ajoutée en tant que gestionnaire plusieurs fois pour un événement unique (comme dans l’exemple ci-dessous), removeListener() supprime l’instance la plus récemment ajoutée. 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 au EventEmitter, afin que les appels puissent être chaînés.

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

Paramètres

eventName

string | symbol

listener

(args: any[]) => void

Retourne

Client

héritée de EventEmitter.removeListener

setMaxListeners(number)

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

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.

function setMaxListeners(n: number): Client

Paramètres

n

number

Retourne

Client

héritée de EventEmitter.setMaxListeners

[captureRejectionSymbol](Error, string | symbol, any[])

La Symbol.for('nodejs.rejection') méthode est appelée au cas où un rejet de promesse survient lors de l’émission d’un événement et captureRejections est activée sur l’émetteur. Il est possible d’utiliser events.captureRejectionSymbol à la place de Symbol.for('nodejs.rejection').

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

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])

Paramètres

error

Error

event

string | symbol

args

any[]

Hérité de EventEmitter.__@captureRejectionSymbol@88