Client class
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.
- Extends
-
EventEmitter
Propriétés héritées
capture |
Modifiez l’option de |
capture |
Valeur : Découvrez comment écrire un |
default |
Par défaut, un maximum d’écouteurs Prenez attention lors de la définition de la Ce n’est pas une limite difficile. L’instance de
L’indicateur de ligne de commande L’avertissement émis peut être inspecté avec |
error |
Ce symbole doit être utilisé pour installer un écouteur pour surveiller uniquement les événements L’installation d’un écouteur à l’aide de ce symbole ne modifie pas le comportement une fois qu’un événement |
Méthodes
close() | |
close(Incoming |
Ferme la connexion à un hub IoT. |
from |
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. |
from |
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. |
from |
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. |
get |
|
get |
Retourne un objet AmqpReceiver qui émet des événements lorsque de nouveaux messages de commentaires sont reçus par le client. |
get |
|
get |
Retourne un objet AmqpReceiver qui émet des événements lorsque de nouvelles notifications de chargement de fichier sont reçues par le client. |
invoke |
|
invoke |
Appelle une méthode sur un appareil ou un module particulier. |
invoke |
|
invoke |
|
open() | |
open(Incoming |
Ouvre la connexion à un hub IoT. |
send(string, Message | Buffer |
|
send(string, Message | Buffer |
Envoie un message à un appareil. |
set |
Définissez la stratégie utilisée par le client pour réessayer les opérations réseau. |
Méthodes héritées
add |
Écoute une fois l’événement L’écoute de l’événement Cette API permet d’utiliser en toute sécurité des Retourne un jetable afin qu’il puisse être désabonné plus facilement.
|
add |
Alias pour |
add |
|
emit<Event |
Appelle de manière synchrone chacun des écouteurs inscrits pour l’événement nommé Retourne
|
emit<Event |
|
event |
Retourne un tableau répertoriant les événements pour lesquels l’émetteur a enregistré des écouteurs. Les valeurs du tableau sont des chaînes ou des
|
get |
|
get |
Retourne une copie du tableau d’écouteurs pour l’événement nommé Pour Pour
|
get |
Retourne la valeur maximale actuelle de l’écouteur pour l' |
get |
Retourne la quantité maximale actuellement définie d’écouteurs. Pour Pour
|
listener |
Méthode de classe qui retourne le nombre d’écouteurs pour la
|
listener |
Retourne le nombre d’écouteurs à l’écoute de l’événement nommé |
listener |
|
listener |
Méthode de classe qui retourne le nombre d’écouteurs pour la
|
listeners<Event |
Retourne une copie du tableau d’écouteurs pour l’événement nommé
|
listeners<Event |
|
off<Event |
Alias pour |
off<Event |
|
on(Event |
|
on(Event |
|
on<Event |
Ajoute la fonction
Retourne une référence au Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode
|
on<Event |
|
on<Events, Event |
Retourne un Une
Utilisez l’option
|
once(Event |
|
once(Event |
|
once<Event |
Ajoute une fonction
Retourne une référence au Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode
|
once<Event |
|
once<Events, Event |
Crée un Cette méthode est intentionnellement générique et fonctionne avec la plateforme web l’interface EventTarget, qui n’a aucune sémantique d’événement
La gestion spéciale de l’événement
Une
|
prepend |
Ajoute la fonction
Retourne une référence au |
prepend |
|
prepend |
Ajoute une fonction
Retourne une référence au |
prepend |
|
raw |
Retourne une copie du tableau d’écouteurs pour l’événement nommé
|
raw |
|
remove |
Supprime tous les écouteurs, ou ceux de la Il est déconseillé de supprimer les écouteurs ajoutés ailleurs dans le code, en particulier lorsque l’instance de Retourne une référence au |
remove |
|
remove |
Supprime le
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 les appels
Étant donné que les écouteurs sont gérés à l’aide d’un tableau interne, l’appel change les index de position de n’importe quel écouteur inscrit après l’écouteur en cours de suppression. 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 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),
Retourne une référence au |
remove |
|
set |
Par défaut, Retourne une référence au |
set |
|
[capture |
|
[capture |
Détails de la propriété héritée
captureRejections
Modifiez l’option de captureRejections
par défaut sur tous les nouveaux objets EventEmitter
.
static captureRejections: boolean
Valeur de propriété
boolean
héritée de EventEmitter.captureRejections
captureRejectionSymbol
Valeur : Symbol.for('nodejs.rejection')
Découvrez comment écrire un rejection handler
personnalisé.
static captureRejectionSymbol: typeof captureRejectionSymbol
Valeur de propriété
typeof captureRejectionSymbol
héritée de EventEmitter.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 les instances de EventEmitter
individuelles à l’aide de la méthode emitter.setMaxListeners(n)
. Pour modifier la valeur par défaut pour toutes les instancesEventEmitter
, la propriété events.defaultMaxListeners
peut être utilisée. Si cette valeur n’est pas un nombre positif, une RangeError
est levée.
Prenez attention lors de la définition de la events.defaultMaxListeners
, car la modification affecte toutes les instancesEventEmitter
, y compris celles créées avant la modification. Toutefois, l’appel emitter.setMaxListeners(n)
a toujours la priorité sur events.defaultMaxListeners
.
Ce n’est pas une limite difficile. L’instance de EventEmitter
permettra à d’autres écouteurs d’être ajoutés, mais génère un avertissement de trace à stderr indiquant qu’une « fuite de mémoire EventEmitter possible » a été détectée. Pour n’importe quel EventEmitter
unique, les méthodes emitter.getMaxListeners()
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 de ligne de commande --trace-warnings
peut être utilisé pour afficher la trace de pile pour ces avertissements.
L’avertissement émis peut être inspecté avec process.on('warning')
et aura les emitter
, type
et les propriétés count
supplémentaires, faisant référence à l’instance de l’émetteur d’événement, au nom de l’événement et au nombre d’écouteurs attachés, respectivement.
Sa propriété name
est définie sur 'MaxListenersExceededWarning'
.
static defaultMaxListeners: number
Valeur de propriété
number
héritée de EventEmitter.defaultMaxListeners
errorMonitor
Ce symbole doit être utilisé pour installer un écouteur pour surveiller uniquement les événements 'error'
. Les écouteurs installés à l’aide de ce symbole sont appelés avant que les écouteurs standard 'error'
soient appelés.
L’installation d’un écouteur à l’aide de ce symbole ne modifie pas le comportement une fois qu’un événement 'error'
est émis. Par conséquent, le processus se bloque toujours si aucun écouteur de 'error'
standard n’est installé.
static errorMonitor: typeof errorMonitor
Valeur de propriété
typeof errorMonitor
héritée de EventEmitter.errorMonitor
Détails de la méthode
close()
function close(): Promise<ResultWithIncomingMessage<Disconnected>>
Retours
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
Retours
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
Retours
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
Retours
getFeedbackReceiver()
function getFeedbackReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>
Retours
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>>
Retours
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
Retours
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
Retours
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>>
Retours
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
Retours
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
addAbortListener(AbortSignal, (event: Event) => void)
Écoute une fois l’événement abort
sur la signal
fournie.
L’écoute de l’événement abort
sur les signaux d’abandon est dangereux et peut entraîner des fuites de ressources, car un autre tiers avec le signal peut appeler e.stopImmediatePropagation()
. Malheureusement, Node.js ne peut pas changer cette situation, car elle violerait la norme web. En outre, l’API d’origine facilite l’oubli de supprimer les écouteurs.
Cette API permet d’utiliser en toute sécurité des AbortSignal
s dans Node.js API en résolvant ces deux problèmes en écoutant l’événement de sorte que stopImmediatePropagation
n’empêche pas l’écouteur d’être en cours d’exécution.
Retourne un jetable afin qu’il puisse être désabonné 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ée de EventEmitter.addAbortListener
addListener<EventName>(EventName, Listener<{}, EventName>)
Alias pour emitter.on(eventName, listener)
.
function addListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.addListener
addListener<EventName>(EventName, Listener<{}, EventName>)
function addListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.addListener
emit<EventName>(EventName, Args<{}, EventName>)
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<EventName>(eventName: EventName, args: Args<{}, EventName>): boolean
Paramètres
- eventName
-
EventName
- args
-
Args<{}, EventName>
Retours
boolean
héritée de EventEmitter.emit
emit<EventName>(EventName, Args<{}, EventName>)
function emit<EventName>(eventName: EventName, args: Args<{}, EventName>): boolean
Paramètres
- eventName
-
EventName
- args
-
Args<{}, EventName>
Retours
boolean
héritée de EventEmitter.emit
eventNames()
Retourne un tableau répertoriant les événements pour lesquels l’émetteur a enregistré des écouteurs. Les valeurs du tableau sont des chaînes ou des Symbol
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ée de EventEmitter.eventNames
getEventListeners(EventEmitter<{}> | EventTarget, string | symbol)
static function getEventListeners(emitter: EventEmitter<{}> | EventTarget, name: string | symbol): Function[]
Paramètres
- emitter
-
EventEmitter<{}> | EventTarget
- name
-
string | symbol
Retours
Function[]
héritée de EventEmitter.getEventListeners
getEventListeners<Events, EventName>(EventEmitter<Events>, EventName)
Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName
.
Pour EventEmitter
s, cela se comporte exactement comme l’appel de .listeners
sur l’émetteur.
Pour EventTarget
s, 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<Events, EventName>(emitter: EventEmitter<Events>, name: EventName): Listener<Events, EventName>[]
Paramètres
- emitter
-
EventEmitter<Events>
- name
-
EventName
Retours
Listener<Events, EventName>[]
héritée de EventEmitter.getEventListeners
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 defaultMaxListeners.
function getMaxListeners(): number
Retours
number
héritée de EventEmitter.getMaxListeners
getMaxListeners(EventEmitter<{}> | EventTarget)
Retourne la quantité maximale actuellement définie d’écouteurs.
Pour EventEmitter
s, cela se comporte exactement comme l’appel de .getMaxListeners
sur l’émetteur.
Pour EventTarget
s, il s’agit de la seule façon d’obtenir les écouteurs d’événements max pour la cible d’événement. Si le nombre de gestionnaires d’événements sur un seul EventTarget dépasse le nombre maximal défini, 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<{}> | EventTarget): number
Paramètres
- emitter
-
EventEmitter<{}> | EventTarget
Retours
number
héritée de EventEmitter.getMaxListeners
listenerCount(EventEmitter<{}>, 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 la eventName
donnée inscrite sur le emitter
donné.
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<{}>, eventName: string | symbol): number
Paramètres
- emitter
-
EventEmitter<{}>
Émetteur à interroger
- eventName
-
string | symbol
Nom de l’événement
Retours
number
héritée de EventEmitter.listenerCount
listenerCount<EventName>(EventName, Listener<{}, EventName>)
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<EventName>(eventName: EventName, listener?: Listener<{}, EventName>): number
Paramètres
- eventName
-
EventName
Nom de l’événement en cours d’écoute
- listener
-
Listener<{}, EventName>
Fonction du gestionnaire d’événements
Retours
number
héritée de EventEmitter.listenerCount
listenerCount<EventName>(EventName, Listener<{}, EventName>)
function listenerCount<EventName>(eventName: EventName, listener?: Listener<{}, EventName>): number
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
number
héritée de EventEmitter.listenerCount
listenerCount<Events, EventName>(EventEmitter<Events>, EventName)
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 la eventName
donnée inscrite sur le emitter
donné.
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<Events, EventName>(emitter: EventEmitter<Events>, eventName: EventName): number
Paramètres
- emitter
-
EventEmitter<Events>
Émetteur à interroger
- eventName
-
EventName
Nom de l’événement
Retours
number
héritée de EventEmitter.listenerCount
listeners<EventName>(EventName)
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<EventName>(eventName: EventName): Listener<{}, EventName>[]
Paramètres
- eventName
-
EventName
Retours
Listener<{}, EventName>[]
héritée de EventEmitter.listeners
listeners<EventName>(EventName)
function listeners<EventName>(eventName: EventName): Listener<{}, EventName>[]
Paramètres
- eventName
-
EventName
Retours
Listener<{}, EventName>[]
héritée de EventEmitter.listeners
off<EventName>(EventName, Listener<{}, EventName>)
Alias pour emitter.removeListener()
.
function off<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.off
off<EventName>(EventName, Listener<{}, EventName>)
function off<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.off
on(EventEmitter<{}>, string | symbol, StaticEventEmitterIteratorOptions)
static function on(emitter: EventEmitter<{}>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>
Paramètres
- emitter
-
EventEmitter<{}>
- eventName
-
string | symbol
- options
-
StaticEventEmitterIteratorOptions
Retours
AsyncIterator<any[], any, any>
héritée de EventEmitter.on
on(EventTarget, string, StaticEventEmitterIteratorOptions)
static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>
Paramètres
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterIteratorOptions
Retours
AsyncIterator<any[], any, any>
héritée de EventEmitter.on
on<EventName>(EventName, Listener<{}, EventName>)
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<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
Nom de l’événement.
- listener
-
Listener<{}, EventName>
Fonction de rappel
Retours
héritée de EventEmitter.on
on<EventName>(EventName, Listener<{}, EventName>)
function on<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.on
on<Events, EventName>(EventEmitter<Events>, EventName, StaticEventEmitterIteratorOptions)
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
});
for await (const event of on(ee, 'foo')) {
// The execution of this inner block is synchronous and it
// processes one event at a time (even with await). Do not use
// if concurrent execution is required.
console.log(event); // prints ['bar'] [42]
}
// Unreachable here
Retourne un AsyncIterator
qui itère eventName
événements. Elle lève si le EventEmitter
émet 'error'
. Elle supprime tous les écouteurs lors de la sortie de la boucle. La value
retournée par chaque itération est un tableau composé des arguments d’événement émis.
Une AbortSignal
peut être utilisée pour annuler l’attente sur les é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());
Utilisez l’option close
pour spécifier un tableau de noms d’événements qui met fin à l’itération :
import { on, EventEmitter } from 'node:events';
import process from 'node:process';
const ee = new EventEmitter();
// Emit later on
process.nextTick(() => {
ee.emit('foo', 'bar');
ee.emit('foo', 42);
ee.emit('close');
});
for await (const event of on(ee, 'foo', { close: ['close'] })) {
console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
static function on<Events, EventName>(emitter: EventEmitter<Events>, eventName: EventName, options?: StaticEventEmitterIteratorOptions): AsyncIterator<Args<Events, EventName>, any, any>
Paramètres
- emitter
-
EventEmitter<Events>
- eventName
-
EventName
- options
-
StaticEventEmitterIteratorOptions
Retours
AsyncIterator<Args<Events, EventName>, any, any>
Un AsyncIterator
qui itère les événements eventName
émis par le emitter
héritée de EventEmitter.on
once(EventEmitter<{}>, string | symbol, StaticEventEmitterOptions)
static function once(emitter: EventEmitter<{}>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>
Paramètres
- emitter
-
EventEmitter<{}>
- eventName
-
string | symbol
- options
-
StaticEventEmitterOptions
Retours
Promise<any[]>
héritée de EventEmitter.once
once(EventTarget, string, StaticEventEmitterOptions)
static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>
Paramètres
- emitter
-
EventTarget
- eventName
-
string
- options
-
StaticEventEmitterOptions
Retours
Promise<any[]>
héritée de EventEmitter.once
once<EventName>(EventName, Listener<{}, EventName>)
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<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
Nom de l’événement.
- listener
-
Listener<{}, EventName>
Fonction de rappel
Retours
héritée de EventEmitter.once
once<EventName>(EventName, Listener<{}, EventName>)
function once<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.once
once<Events, EventName>(EventEmitter<Events>, EventName, StaticEventEmitterOptions)
Crée un Promise
qui est rempli lorsque le EventEmitter
émet l’événement donné ou qui est rejeté si le EventEmitter
émet 'error'
en attendant.
Le Promise
est résolu avec un tableau de tous les arguments émis à l’événement donné.
Cette méthode est intentionnellement générique et fonctionne avec la plateforme web l’interface EventTarget, qui n’a aucune sémantique d’événement'error'
spéciale 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énementerror'
lui-même, il est traité comme n’importe quel 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
Une AbortSignal
peut être utilisée 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<Events, EventName>(emitter: EventEmitter<Events>, eventName: EventName, options?: StaticEventEmitterOptions): Promise<Args<Events, EventName>>
Paramètres
- emitter
-
EventEmitter<Events>
- eventName
-
EventName
- options
-
StaticEventEmitterOptions
Retours
Promise<Args<Events, EventName>>
héritée de EventEmitter.once
prependListener<EventName>(EventName, Listener<{}, EventName>)
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<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
Nom de l’événement.
- listener
-
Listener<{}, EventName>
Fonction de rappel
Retours
héritée de EventEmitter.prependListener
prependListener<EventName>(EventName, Listener<{}, EventName>)
function prependListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.prependListener
prependOnceListener<EventName>(EventName, Listener<{}, EventName>)
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<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
Nom de l’événement.
- listener
-
Listener<{}, EventName>
Fonction de rappel
Retours
héritée de EventEmitter.prependOnceListener
prependOnceListener<EventName>(EventName, Listener<{}, EventName>)
function prependOnceListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.prependOnceListener
rawListeners<EventName>(EventName)
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<EventName>(eventName: EventName): Listener<{}, EventName>[]
Paramètres
- eventName
-
EventName
Retours
Listener<{}, EventName>[]
héritée de EventEmitter.rawListeners
rawListeners<EventName>(EventName)
function rawListeners<EventName>(eventName: EventName): Listener<{}, EventName>[]
Paramètres
- eventName
-
EventName
Retours
Listener<{}, EventName>[]
héritée de EventEmitter.rawListeners
removeAllListeners<EventName>(EventName)
Supprime tous les écouteurs, ou ceux de la eventName
spé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<EventName>(eventName: EventName): Client
Paramètres
- eventName
-
EventName
Retours
héritée de EventEmitter.removeAllListeners
removeAllListeners<EventName>(EventName)
function removeAllListeners<EventName>(eventName?: EventName): Client
Paramètres
- eventName
-
EventName
Retours
héritée de EventEmitter.removeAllListeners
removeListener<EventName>(EventName, Listener<{}, EventName>)
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 eventName
spé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 les appels removeListener()
ou removeAllListeners()
après émission et avant la dernière exécution de l’écouteur ne les supprime 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 change les index de position de n’importe quel écouteur inscrit après l’écouteur en cours de suppression. 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<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.removeListener
removeListener<EventName>(EventName, Listener<{}, EventName>)
function removeListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Client
Paramètres
- eventName
-
EventName
- listener
-
Listener<{}, EventName>
Retours
héritée de EventEmitter.removeListener
setMaxListeners(number)
Par défaut, EventEmitter
s 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
Retours
héritée de EventEmitter.setMaxListeners
setMaxListeners(number, (EventEmitter<{}> | EventTarget)[])
import { setMaxListeners, EventEmitter } from 'node:events';
const target = new EventTarget();
const emitter = new EventEmitter();
setMaxListeners(5, target, emitter);
static function setMaxListeners(n?: number, eventTargets: (EventEmitter<{}> | EventTarget)[])
Paramètres
- n
-
number
Nombre non négatif. Nombre maximal d’écouteurs par événement EventTarget
.
- eventTargets
-
(EventEmitter<{}> | EventTarget)[]
Zéro ou plusieurs instances {EventTarget} ou {EventEmitter}. Si aucun n’est spécifié, n
est défini comme max par défaut pour tous les objets {EventTarget} et {EventEmitter} nouvellement créés.
héritée de EventEmitter.setMaxListeners
[captureRejectionSymbol](Error, string | symbol, any[])
function [captureRejectionSymbol](error: Error, event: string | symbol, args: any[])
Paramètres
- error
-
Error
- event
-
string | symbol
- args
-
any[]
héritée de EventEmitter.__@captureRejectionSymbol@155
[captureRejectionSymbol]<EventName>(Error, EventName, Args<{}, EventName>)
function [captureRejectionSymbol]<EventName>(error: Error, event: EventName, args: Args<{}, EventName>)
Paramètres
- error
-
Error
- event
-
EventName
- args
-
Args<{}, EventName>
héritée de EventEmitter.__@captureRejectionSymbol@155