Partager via

ServiceReceiver interface

  • Référence
Paquet:
azure-iothub
Extends

Receiver

Méthodes

abandon(Message, Callback<MessageAbandoned>)
complete(Message, Callback<MessageCompleted>)
reject(Message, Callback<MessageRejected>)

Méthodes héritées

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

Alias pour emitter.on(eventName, listener).
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 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) ]
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.
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("errorReceived", (err: Error) => void)
on("message", (msg: Message) => void)
on(string, Function)
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
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');
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.
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.
setMaxListeners(number)

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

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

Détails de la méthode

abandon(Message, Callback<MessageAbandoned>) 

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

Paramètres

message

Message

done

Callback<MessageAbandoned>

complete(Message, Callback<MessageCompleted>) 

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

Paramètres

message

Message

done

Callback<MessageCompleted>

reject(Message, Callback<MessageRejected>) 

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

Paramètres

message

Message

done

Callback<MessageRejected>

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

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

Alias pour emitter.on(eventName, listener).

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

Paramètres

eventName

string | symbol

listener

(args: any[]) => void

Retours

ServiceReceiver

héritée de Receiver.addListener

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 Receiver.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 Receiver.eventNames

getMaxListeners()

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

function getMaxListeners(): number

Retours

number

héritée de Receiver.getMaxListeners

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 Receiver.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és de Receiver.listeners

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

Alias pour emitter.removeListener().

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

Paramètres

eventName

string | symbol

listener

(args: any[]) => void

Retours

ServiceReceiver

héritée de Receiver.off

on("errorReceived", (err: Error) => void) 

function on(type: "errorReceived", func: (err: Error) => void): ServiceReceiver

Paramètres

type

"errorReceived"

func

(err: Error) => void

Retours

ServiceReceiver

héritée du récepteur.on

on("message", (msg: Message) => void) 

function on(type: "message", func: (msg: Message) => void): ServiceReceiver

Paramètres

type

"message"

func

(msg: Message) => void

Retours

ServiceReceiver

héritée du récepteur.on

on(string, Function) 

function on(type: string, func: Function): ServiceReceiver

Paramètres

type

string

func

Function

Retours

ServiceReceiver

héritée du récepteur.on

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

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retours

ServiceReceiver

héritée de Receiver.once

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

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retours

ServiceReceiver

héritée de Receiver.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): ServiceReceiver

Paramètres

eventName

string | symbol

Nom de l’événement.

listener

(args: any[]) => void

Fonction de rappel

Retours

ServiceReceiver

héritée de Receiver.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 Receiver.rawListeners

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

Paramètres

eventName

string | symbol

Retours

ServiceReceiver

héritée de Receiver.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): ServiceReceiver

Paramètres

eventName

string | symbol

listener

(args: any[]) => void

Retours

ServiceReceiver

héritée de Receiver.removeListener

setMaxListeners(number)

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

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

function setMaxListeners(n: number): ServiceReceiver

Paramètres

n

number

Retours

ServiceReceiver

héritée de Receiver.setMaxListeners

[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ée de Receiver.__@captureRejectionSymbol@118