Client class

Paquet:: azure-iot-device

Client d’appareil IoT Hub 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

Constructeurs

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

Propriétés héritées

captureRejections	Valeur : booléen Changez l’option par défaut `captureRejections` sur tous les nouveaux `EventEmitter` objets.
captureRejectionSymbol	Valeur : `Symbol.for('nodejs.rejection')` Voyez comment écrire un fichier personnalisé `rejection handler`.
defaultMaxListeners	Par défaut, un maximum d’auditeurs `10` peut être inscrit à un seul événement. Cette limite peut être modifiée pour chaque `EventEmitter` instance en utilisant la `emitter.setMaxListeners(n)` méthode. Pour changer la valeur par défaut pour toutes`EventEmitter` les instances, la `events.defaultMaxListeners` propriété peut être utilisée. Si cette valeur n’est pas un nombre positif, a `RangeError` est lancé. Soyez prudent lors de la mise en place car `events.defaultMaxListeners` le changement affecte toutes`EventEmitter` les instances, y compris celles créées avant la modification. Cependant, appeler `emitter.setMaxListeners(n)` a toujours une priorité sur `events.defaultMaxListeners`. Ce n’est pas une limite stricte. L’instance `EventEmitter` permettra d’ajouter plus d’auditeurs mais enverra un avertissement de trace à stderr indiquant qu’une « fuite mémoire possible EventEmitter » a été détectée. Pour tout , `EventEmitter`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)); });` Le `--trace-warnings` drapeau 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 supplémentaires `emitter`, `type`, et `count` , faisant référence respectivement à l’instance de l’émetteur d’événement, au nom de l’événement et au nombre d’auditeurs attachés. Sa `name` propriété est fixée à `'MaxListenersExceededWarning'`.
errorMonitor	Ce symbole doit être utilisé pour installer un écouteur uniquement pour surveiller `'error'` les événements. Les auditeurs installés avec ce symbole sont appelés avant que les auditeurs réguliers `'error'` ne soient appelés. L’installation d’un écouteur utilisant ce symbole ne change pas le comportement une fois qu’un `'error'` événement est émis. Par conséquent, le processus plante toujours si aucun auditeur régulier `'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 client ne peut pas être réutilisé.
fromAuthenticationProvider(AuthenticationProvider, any)	Crée un client d’appareil 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 de la chaîne de connexion donnée à l’aide du type de transport donné.
fromSharedAccessSignature(string, any)	Crée un client d’appareil IoT Hub à partir de la signature d’accès partagé donnée à l’aide du type de transport donné.
getBlobSharedAccessSignature(string)
getBlobSharedAccessSignature(string, Callback<UploadParams>)	Le `getBlobSharedAccessSignature` obtient le jeton SAP du compte de stockage lié à partir d’IoT Hub
notifyBlobUploadStatus(string, boolean, number, string)
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)	La méthode `notifyBlobUploadStatus` envoie IoT Hub le résultat d’un chargement d’objet blob.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)	Inscrit un rappel pour une méthode nommée `methodName`.
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
uploadToBlob(string, Stream, number)
uploadToBlob(string, Stream, number, ErrorCallback)	La méthode `uploadToBlob` charge un flux dans un objet blob.

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 point fourni `signal`. Écouter l’événement `abort` sur les signaux d’interruption est dangereux et peut entraîner des fuites de ressources puisque un autre tiers possédant le signal peut appeler `e.stopImmediatePropagation()`. Malheureusement, Node.js ne peut pas changer cela car cela violerait la norme web. De plus, l’API originale permet d’oublier facilement de supprimer les auditeurs. Cette API permet d’utiliser `AbortSignal`en toute sécurité s dans Node.js API en résolvant ces deux problèmes en écoutant l’événement de manière à `stopImmediatePropagation` ne pas empêcher l’écouteur de s’exécuter. Retourne un jetable pour qu’il puisse être plus facilement désabonné. `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 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. 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) ]`
getEventListeners(EventEmitter<DefaultEventMap> \| EventTarget, string \| symbol)	Retourne une copie du tableau d’écouteurs pour l’événement nommé `eventName`. Pour `EventEmitter`s, cela se comporte exactement de la même manière que d’appeler `.listeners` l’émetteur. Pour `EventTarget`s, c’est la seule façon d’obtenir les auditeurs de l’événement pour la cible de l’événement. Cela est utile pour le débogage et le 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 maximale actuelle de l’écouteur pour l'`EventEmitter` qui est définie par `emitter.setMaxListeners(n)` ou par défaut sur <xref:EventEmitter.defaultMaxListeners>.
getMaxListeners(EventEmitter<DefaultEventMap> \| EventTarget)	Rend le nombre maximal d’auditeurs actuellement fixé. Pour `EventEmitter`s, cela se comporte exactement de la même manière que d’appeler `.getMaxListeners` l’émetteur. Pour `EventTarget`s, c’est la seule façon d’obtenir le maximum d’auditeurs d’événements pour la cible d’événement. Si le nombre de gestionnaires d’événements sur un seul EventTarget dépasse le set maximal, l’EventTarget affichera 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)	Une méthode de classe qui retourne le nombre d’auditeurs pour le donné `eventName` enregistré sur le .`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 à 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<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 \| symbol, StaticEventEmitterIteratorOptions)	`import { on, EventEmitter } from 'node:events'; import process from 'node:process'; const ee = new EventEmitter(); // Emit later on process.nextTick(() => { ee.emit('foo', 'bar'); ee.emit('foo', 42); }); for await (const event of on(ee, 'foo')) { // The execution of this inner block is synchronous and it // processes one event at a time (even with await). Do not use // if concurrent execution is required. console.log(event); // prints ['bar'] [42] } // Unreachable here` Des retours qui `AsyncIterator` itèrent `eventName` les événements. Il projette si l’émet `EventEmitter'error'`. Il supprime tous les auditeurs lors de la sortie de la boucle. Le `value` rendu par chaque itération est un tableau composé des arguments des événements émis. An peut être utilisé pour annuler l’attente `AbortSignal` des é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 mettra 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'`
on(EventTarget, string, StaticEventEmitterIteratorOptions)
on<K>(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(EventEmitter<DefaultEventMap>, string \| symbol, 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` règlement se résoudra avec un tableau de tous les arguments émis à l’événement donné. Cette méthode est volontairement générique et fonctionne avec l’interface EventTarget de la plateforme web, qui ne possède aucune sémantique d’événement spécial`'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'` n’est utilisée que lorsqu’il `events.once()` est utilisé pour attendre un autre événement. Si `events.once()` est utilisé pour attendre l’événement '`error'` lui-même, alors il est traité comme tout autre type d’événement sans traitement spécial : `import { EventEmitter, once } from 'node:events'; const ee = new EventEmitter(); once(ee, 'error') .then(([err]) => console.log('ok', err.message)) .catch((err) => console.error('error', err.message)); ee.emit('error', new Error('boom')); // Prints: ok boom` An peut être utilisé pour annuler l’attente `AbortSignal` 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(EventTarget, string, StaticEventEmitterOptions)
once<K>(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`
open()
open(Callback<Connected>)
prependListener<K>(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<K>(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<K>(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');
reject(Message)
reject(Message, Callback<MessageRejected>)
removeAllListeners(string \| symbol)	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.
removeListener<K>(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 `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 de`emit()` 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.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
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.
setMaxListeners(number, (EventEmitter<DefaultEventMap> \| EventTarget)[])	`import { setMaxListeners, EventEmitter } from 'node:events'; const target = new EventTarget(); const emitter = new EventEmitter(); setMaxListeners(5, target, emitter);`
setRetryPolicy(RetryPolicy)	Définit la stratégie de nouvelle tentative utilisée par le client sur toutes les opérations. La valeur par défaut est ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string \| symbol, AnyRest)

Détails du constructeur

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

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

Paramètres

transport: DeviceTransport

Objet qui implémente l’interface attendue d’un objet de transport, par exemple, Http.

connStr: string

Chaîne de connexion (facultative : lorsqu’elle n’est pas fournie, updateSharedAccessSignature doit être appelée pour définir directement le jeton SharedAccessSignature).

blobUploadClient: BlobUploadClient

Objet capable de charger un flux dans un objet blob.

fileUploadApi: FileUploadInterface

Objet utilisé pour communiquer avec IoT Hub pour les actions associées au Stockage Blob.

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

captureRejections

Valeur : booléen

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

static captureRejections: boolean

Valeur de propriété

boolean

Hérités de InternalClient.captureRejections

captureRejectionSymbol

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

Voyez comment écrire un fichier personnalisé rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valeur de propriété

typeof captureRejectionSymbol

Hérité de InternalClient.captureRejectionSymbole

defaultMaxListeners

Par défaut, un maximum d’auditeurs 10 peut être inscrit à un seul événement. Cette limite peut être modifiée pour chaque EventEmitter instance en utilisant la emitter.setMaxListeners(n) méthode. Pour changer la valeur par défaut pour toutesEventEmitter les instances, la events.defaultMaxListeners propriété peut être utilisée. Si cette valeur n’est pas un nombre positif, a RangeError est lancé.

Soyez prudent lors de la mise en place car events.defaultMaxListeners le changement affecte toutesEventEmitter les instances, y compris celles créées avant la modification. Cependant, appeler emitter.setMaxListeners(n) a toujours une priorité sur events.defaultMaxListeners.

Ce n’est pas une limite stricte. L’instance EventEmitter permettra d’ajouter plus d’auditeurs mais enverra un avertissement de trace à stderr indiquant qu’une « fuite mémoire possible EventEmitter » a été détectée. Pour tout , EventEmitterles 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));
});

Le --trace-warnings drapeau 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 supplémentaires emitter, type, et count , faisant référence respectivement à l’instance de l’émetteur d’événement, au nom de l’événement et au nombre d’auditeurs attachés. Sa name propriété est fixée à '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 surveiller 'error' les événements. Les auditeurs installés avec ce symbole sont appelés avant que les auditeurs réguliers 'error' ne soient appelés.

L’installation d’un écouteur utilisant ce symbole ne change pas le comportement une fois qu’un 'error' événement est émis. Par conséquent, le processus plante toujours si aucun auditeur régulier '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 client 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 d’appareil 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): Client

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

Client

fromConnectionString(string, any)

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

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

Paramètres

connStr: string

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

transportCtor: any

Constructeur de transport.

Retours

Client

fromSharedAccessSignature(string, any)

Crée un client d’appareil 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): Client

Paramètres

sharedAccessSignature: string

Signature d’accès partagé qui encapsule les autorisations « device connect » sur un hub IoT.

transportCtor: any

Retours

Client

getBlobSharedAccessSignature(string)

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

Paramètres

blobName: string

Retours

Promise<UploadParams>

getBlobSharedAccessSignature(string, Callback<UploadParams>)

Le getBlobSharedAccessSignature obtient le jeton SAP du compte de stockage lié à partir d’IoT Hub

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

Paramètres

blobName: string

Nom à utiliser pour l’objet blob qui sera créé avec le contenu du flux.

callback: Callback<UploadParams>

Rappel facultatif pour appeler une fois le chargement terminé.

notifyBlobUploadStatus(string, boolean, number, string)

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

Paramètres

correlationId: string

isSuccess: boolean

statusCode: number

statusDescription: string

Retours

Promise<void>

notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)

La méthode notifyBlobUploadStatus envoie IoT Hub le résultat d’un chargement d’objet blob.

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

Paramètres

correlationId: string

ID pour la corrélation d’un état de chargement vers un objet blob spécifique. Généré pendant l’appel à getBlobSharedAccessSignature.

isSuccess: boolean

État de réussite ou d’échec du résultat de l’opération d’objet blob de stockage.

statusCode: number

Code d’état HTTP associé au résultat de l’objet blob de stockage.

statusDescription: string

Description du code d’état HTTP.

callback: ErrorCallback

Rappel facultatif pour appeler une fois le chargement terminé.

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

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

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

Paramètres

methodName: string

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

callback: (request: DeviceMethodRequest, response: DeviceMethodResponse) => void

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

setOptions(DeviceClientOptions)

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

Paramètres

options: DeviceClientOptions

Retours

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

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

Paramètres

options: DeviceClientOptions

done: Callback<TransportConfigured>

uploadToBlob(string, Stream, number)

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

Paramètres

blobName: string

stream: Stream

streamLength: number

Retours

Promise<void>

uploadToBlob(string, Stream, number, ErrorCallback)

La méthode uploadToBlob charge un flux dans un objet blob.

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

Paramètres

blobName: string

Nom à utiliser pour l’objet blob qui sera créé avec le contenu du flux.

stream: Stream

Les données à ce dernier doivent être chargées dans l’objet blob.

streamLength: number

Taille des données à charger dans l’objet blob.

callback: ErrorCallback

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ée de InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>)

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

Paramètres

message: Message

abandonCallback: Callback<MessageAbandoned>

héritée de InternalClient.abandon

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

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

Écouter l’événement abort sur les signaux d’interruption est dangereux et peut entraîner des fuites de ressources puisque un autre tiers possédant le signal peut appeler e.stopImmediatePropagation(). Malheureusement, Node.js ne peut pas changer cela car cela violerait la norme web. De plus, l’API originale permet d’oublier facilement de supprimer les auditeurs.

Cette API permet d’utiliser AbortSignalen toute sécurité s dans Node.js API en résolvant ces deux problèmes en écoutant l’événement de manière à stopImmediatePropagation ne pas empêcher l’écouteur de s’exécuter.

Retourne un jetable pour qu’il puisse être plus facilement désabonné.

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 enlève l’auditeur 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): Client

Paramètres

eventName: string | symbol

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

Retours

Client

héritée de InternalClient.addListener

complete(Message)

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

Paramètres

message: Message

Retours

Promise<MessageCompleted>

héritée de InternalClient.complete

complete(Message, Callback<MessageCompleted>)

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

Paramètres

message: Message

completeCallback: Callback<MessageCompleted>

héritée de InternalClient.complete

emit<K>(string | symbol, AnyRest)

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<K>(eventName: string | symbol, args: AnyRest): boolean

Paramètres

eventName: string | symbol

args: AnyRest

Retours

boolean

héritée de InternalClient.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 Symbols.

import { EventEmitter } from 'node:events';

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

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

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

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

Retours

(string | symbol)[]

héritée de InternalClient.eventNames

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

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

Pour EventEmitters, cela se comporte exactement de la même manière que d’appeler .listeners l’émetteur.

Pour EventTargets, c’est la seule façon d’obtenir les auditeurs de l’événement pour la cible de l’événement. Cela est utile pour le débogage et le 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> | EventTarget, name: string | symbol): Function[]

Paramètres

emitter: EventEmitter<DefaultEventMap> | EventTarget

name: string | symbol

Retours

Function[]

Hérité de InternalClient.getEventAuditeurs

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 <xref:EventEmitter.defaultMaxListeners>.

function getMaxListeners(): number

Retours

number

héritée de InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Rend le nombre maximal d’auditeurs actuellement fixé.

Pour EventEmitters, cela se comporte exactement de la même manière que d’appeler .getMaxListeners l’émetteur.

Pour EventTargets, c’est la seule façon d’obtenir le maximum d’auditeurs d’événements pour la cible d’événement. Si le nombre de gestionnaires d’événements sur un seul EventTarget dépasse le set maximal, l’EventTarget affichera 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> | EventTarget): number

Paramètres

emitter: EventEmitter<DefaultEventMap> | EventTarget

Retours

number

héritée de InternalClient.getMaxListeners

getTwin()

function getTwin(): Promise<Twin>

Retours

Promise<Twin>

héritée de InternalClient.getTwin

getTwin(Callback<Twin>)

function getTwin(done: Callback<Twin>)

Paramètres

done: Callback<Twin>

héritée de InternalClient.getTwin

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Avertissement

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

Since v3.2.0 - Use listenerCount instead.

Une méthode de classe qui retourne le nombre d’auditeurs pour le donné eventName enregistré sur le .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>

L’émetteur à interroger

eventName: string | symbol

Nom de l’événement

Retours

number

héritée de InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

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<K>(eventName: string | symbol, listener?: Function): number

Paramètres

eventName: string | symbol

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

listener: Function

Fonction du gestionnaire d’événements

Retours

number

héritée 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ée de InternalClient.listeners

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

Alias pour emitter.removeListener().

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

Paramètres

eventName: string | symbol

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

Retours

Client

héritée de InternalClient.off

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

import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

Des retours qui AsyncIterator itèrent eventName les événements. Il projette si l’émet EventEmitter'error'. Il supprime tous les auditeurs lors de la sortie de la boucle. Le value rendu par chaque itération est un tableau composé des arguments des événements émis.

An peut être utilisé pour annuler l’attente AbortSignal des é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 mettra 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(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Paramètres

emitter: EventEmitter<DefaultEventMap>

eventName: string | symbol

options: StaticEventEmitterIteratorOptions

Retours

AsyncIterator<any[], any, any>

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

héritée de InternalClient.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 InternalClient.on

on<K>(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<K>(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

Retours

Client

héritée de InternalClient.on

once(EventEmitter<DefaultEventMap>, string | symbol, 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 règlement se résoudra avec un tableau de tous les arguments émis à l’événement donné.

Cette méthode est volontairement générique et fonctionne avec l’interface EventTarget de la plateforme web, qui ne possède aucune sémantique d’événement spécial'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' n’est utilisée que lorsqu’il events.once() est utilisé pour attendre un autre événement. Si events.once() est utilisé pour attendre l’événement 'error' lui-même, alors il est traité comme tout autre type d’événement sans traitement spécial :

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

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

An peut être utilisé pour annuler l’attente AbortSignal 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ée de InternalClient.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 InternalClient.once

once<K>(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<K>(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

Retours

Client

héritée de InternalClient.once

open()

function open(): Promise<Connected>

Retours

Promise<Connected>

héritée de InternalClient.open

open(Callback<Connected>)

function open(openCallback: Callback<Connected>)

Paramètres

openCallback: Callback<Connected>

héritée de InternalClient.open

prependListener<K>(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<K>(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

Retours

Client

héritée de InternalClient.prependListener

prependOnceListener<K>(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<K>(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

Retours

Client

héritée de InternalClient.prependOnceListener

rawListeners<K>(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<K>(eventName: string | symbol): Function[]

Paramètres

eventName: string | symbol

Retours

Function[]

héritée de InternalClient.rawListeners

reject(Message)

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

Paramètres

message: Message

Retours

Promise<MessageRejected>

héritée de InternalClient.reject

reject(Message, Callback<MessageRejected>)

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

Paramètres

message: Message

rejectCallback: Callback<MessageRejected>

héritée de InternalClient.reject

removeAllListeners(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(eventName?: string | symbol): Client

Paramètres

eventName: string | symbol

Retours

Client

héritée de InternalClient.removeAllListeners

removeListener<K>(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 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<K>(eventName: string | symbol, listener: (args: any[]) => void): Client

Paramètres

eventName: string | symbol

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

Retours

Client

héritée de InternalClient.removeListener

sendEvent(Message)

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

Paramètres

message: Message

Retours

Promise<MessageEnqueued>

héritée de InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>)

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

Paramètres

message: Message

sendEventCallback: Callback<MessageEnqueued>

héritée de InternalClient.sendEvent

sendEventBatch(Message[])

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

Paramètres

messages: Message[]

Retours

Promise<MessageEnqueued>

héritée de InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>)

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

Paramètres

messages: Message[]

sendEventBatchCallback: Callback<MessageEnqueued>

héritée de InternalClient.sendEventBatch

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

Retours

Client

héritée de InternalClient.setMaxListeners

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

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

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

setMaxListeners(5, target, emitter);

static function setMaxListeners(n?: number, eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[])

Paramètres

n: number

Un nombre non négatif. Le nombre maximal d’auditeurs par EventTarget événement.

eventTargets: (EventEmitter<DefaultEventMap> | EventTarget)[]

Zéro ou plus d’instances {EventTarget} ou {EventEmitter}. Si aucun n’est spécifié, n est défini comme maximum par défaut pour tous les nouveaux objets {EventTarget} et {EventEmitter} nouvellement créés.

héritée 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 ExponentialBackoffWithJitter.

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ée de InternalClient.setRetryPolicy

setTransportOptions(any)

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

Paramètres

options: any

Retours

Promise<TransportConfigured>

héritée de InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>)

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

Paramètres

options: any

done: Callback<TransportConfigured>

héritée de InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)

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

Paramètres

sharedAccessSignature: string

updateSasCallback: Callback<SharedAccessSignatureUpdated>

héritée 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@141