ServiceReceiver interface
- Extends
-
Receiver
Méthodes
abandon(Message, Callback<Message |
|
complete(Message, Callback<Message |
|
reject(Message, Callback<Message |
Méthodes héritées
add |
Alias pour |
emit<K>(string | symbol, Any |
Appelle de façon synchrone chacun des écouteurs inscrits pour l’événement nommé Retourne
|
event |
Retourne un tableau répertoriant les événements pour lesquels l’émetteur a inscrit des écouteurs. Les valeurs du tableau sont des chaînes ou
|
get |
Retourne la valeur d’écouteur maximale actuelle pour le |
listener |
Retourne le nombre d’écouteurs qui écoutent l’événement nommé |
listeners<K>(string | symbol) | Retourne une copie du tableau d’écouteurs pour l’événement nommé
|
off<K>(string | symbol, (args: any[]) => void) | Alias pour |
on("error |
|
on("message", (msg: Message) => void) | |
on(string, Function) | |
once<K>(string | symbol, (args: any[]) => void) | Ajoute une fonction à usage unique
Retourne une référence à , afin que les Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La
|
prepend |
Ajoute la
Retourne une référence à , afin que les |
prepend |
Ajoute une fonction à usage unique
Retourne une référence à , afin que les |
raw |
Retourne une copie du tableau d’écouteurs pour l’événement nommé
|
remove |
Supprime tous les écouteurs, ou ceux du spécifié Il est déconseillé de supprimer les écouteurs ajoutés ailleurs dans le code, en particulier lorsque le Retourne une référence à , afin que les |
remove |
Supprime le spécifié
Une fois qu’un événement est émis, tous les écouteurs qui y sont attachés au moment de l’émission sont appelés dans l’ordre. Cela implique que les
Étant donné que les écouteurs sont gérés à l’aide d’un tableau interne, l’appel de cela modifie les index de position de tout écouteur inscrit après la suppression de l’écouteur. Cela n’aura pas d’impact sur l’ordre dans lequel les écouteurs sont appelés, mais cela signifie que toutes les copies du tableau d’écouteurs retournées par la Lorsqu’une seule fonction a été ajoutée en tant que gestionnaire plusieurs fois pour un seul événement (comme dans l’exemple ci-dessous),
Retourne une référence à , afin que les |
set |
Par défaut Retourne une référence à , afin que les |
[capture |
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
Hérité de Receiver.addListener
emit<K>(string | symbol, AnyRest)
Appelle de façon synchrone chacun des écouteurs inscrits pour l’événement nommé eventName
, dans l’ordre dans lequel ils ont été inscrits, en passant les arguments fournis à chacun d’eux.
Retourne true
si l’événement avait des écouteurs, false
sinon.
import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();
// First listener
myEmitter.on('event', function firstListener() {
console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
const parameters = args.join(', ');
console.log(`event with parameters ${parameters} in third listener`);
});
console.log(myEmitter.listeners('event'));
myEmitter.emit('event', 1, 2, 3, 4, 5);
// Prints:
// [
// [Function: firstListener],
// [Function: secondListener],
// [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
function emit<K>(eventName: string | symbol, args: AnyRest): boolean
Paramètres
- eventName
-
string | symbol
- args
-
AnyRest
Retours
boolean
Hérité de Receiver.emit
eventNames()
Retourne un tableau répertoriant les événements pour lesquels l’émetteur a inscrit des écouteurs. Les valeurs du tableau sont des chaînes ou Symbol
des s.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});
const sym = Symbol('symbol');
myEE.on(sym, () => {});
console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
function eventNames(): (string | symbol)[]
Retours
(string | symbol)[]
Hérité de Receiver.eventNames
getMaxListeners()
Retourne la valeur d’écouteur maximale actuelle pour le EventEmitter
qui est défini par emitter.setMaxListeners(n)
ou par défaut sur defaultMaxListeners.
function getMaxListeners(): number
Retours
number
Hérité de Receiver.getMaxListeners
listenerCount<K>(string | symbol, Function)
Retourne le nombre d’écouteurs qui écoutent l’événement nommé eventName
.
Si listener
est fourni, il retourne le nombre de fois où l’écouteur se trouve dans la liste des écouteurs de l’événement.
function listenerCount<K>(eventName: string | symbol, listener?: Function): number
Paramètres
- eventName
-
string | symbol
Nom de l’événement écouté
- listener
-
Function
Fonction de gestionnaire d’événements
Retours
number
Hérité de 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é 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
Hérité 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
Hérité de Receiver.on
on("message", (msg: Message) => void)
function on(type: "message", func: (msg: Message) => void): ServiceReceiver
Paramètres
- type
-
"message"
- func
-
(msg: Message) => void
Retours
Hérité de Receiver.on
on(string, Function)
function on(type: string, func: Function): ServiceReceiver
Paramètres
- type
-
string
- func
-
Function
Retours
Hérité de Receiver.on
once<K>(string | symbol, (args: any[]) => void)
Ajoute une fonction à usage uniquelistener
pour l’événement nommé eventName
. La prochaine fois eventName
qu’il est déclenché, cet écouteur est supprimé, puis appelé.
server.once('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Retourne une référence à , afin que les EventEmitter
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 emitter.prependOnceListener()
méthode peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.
import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
// b
// a
function once<K>(eventName: string | symbol, listener: (args: any[]) => void): ServiceReceiver
Paramètres
- eventName
-
string | symbol
Nom de l’événement.
- listener
-
(args: any[]) => void
Fonction de rappel
Retours
Hérité de Receiver.once
prependListener<K>(string | symbol, (args: any[]) => void)
Ajoute la listener
fonction au début du tableau d’écouteurs pour l’événement nommé eventName
. Aucune vérification n’est effectuée pour voir si a listener
déjà été ajouté. Plusieurs appels passant la même combinaison de eventName
et listener
entraînent l’ajout et l’appel listener
de plusieurs fois.
server.prependListener('connection', (stream) => {
console.log('someone connected!');
});
Retourne une référence à , afin que les EventEmitter
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
Hérité de Receiver.prependListener
prependOnceListener<K>(string | symbol, (args: any[]) => void)
Ajoute une fonction à usage uniquelistener
pour l’événement nommé eventName
au début du tableau d’écouteurs. La prochaine fois eventName
qu’est déclenché, cet écouteur est supprimé, puis appelé.
server.prependOnceListener('connection', (stream) => {
console.log('Ah, we have our first user!');
});
Retourne une référence à , afin que les EventEmitter
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
Hérité de Receiver.prependOnceListener
rawListeners<K>(string | symbol)
Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName
, y compris tous les wrappers (tels que ceux créés par .once()
).
import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));
// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];
// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();
// Logs "log once" to the console and removes the listener
logFnWrapper();
emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');
// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
function rawListeners<K>(eventName: string | symbol): Function[]
Paramètres
- eventName
-
string | symbol
Retours
Function[]
Hérité de Receiver.rawListeners
removeAllListeners(string | symbol)
Supprime tous les écouteurs, ou ceux du spécifié eventName
.
Il est déconseillé de supprimer les écouteurs ajoutés ailleurs dans le code, en particulier lorsque le EventEmitter
instance a été créé par un autre composant ou module (par exemple, des sockets ou des flux de fichiers).
Retourne une référence à , afin que les EventEmitter
appels puissent être chaînés.
function removeAllListeners(eventName?: string | symbol): ServiceReceiver
Paramètres
- eventName
-
string | symbol
Retours
Hérité de Receiver.removeAllListeners
removeListener<K>(string | symbol, (args: any[]) => void)
Supprime le spécifié listener
du tableau d’écouteurs pour l’événement nommé eventName
.
const callback = (stream) => {
console.log('someone connected!');
};
server.on('connection', callback);
// ...
server.removeListener('connection', callback);
removeListener()
supprimera, au maximum, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le spécifié eventName
, removeListener()
vous devez être appelé plusieurs fois pour supprimer chaque instance.
Une fois qu’un événement est émis, tous les écouteurs qui y sont attachés au moment de l’émission sont appelés dans l’ordre. Cela implique que les removeListener()
appels ou removeAllListeners()
après l’émission et avant la fin de l’exécution du dernier écouteur ne les suppriment pas deemit()
en cours. Les événements suivants se comportent comme prévu.
import { EventEmitter } from 'node:events';
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
const callbackA = () => {
console.log('A');
myEmitter.removeListener('event', callbackB);
};
const callbackB = () => {
console.log('B');
};
myEmitter.on('event', callbackA);
myEmitter.on('event', callbackB);
// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
// A
// B
// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
// A
Étant donné que les écouteurs sont gérés à l’aide d’un tableau interne, l’appel de cela modifie les index de position de tout écouteur inscrit après la suppression de l’écouteur. Cela n’aura pas d’impact sur l’ordre dans lequel les écouteurs sont appelés, mais cela signifie que toutes les copies du tableau d’écouteurs retournées par la emitter.listeners()
méthode devront être recréées.
Lorsqu’une seule fonction a été ajoutée en tant que gestionnaire plusieurs fois pour un seul événement (comme dans l’exemple ci-dessous), removeListener()
supprime la dernière instance 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 à , afin que les EventEmitter
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
Hérité de Receiver.removeListener
setMaxListeners(number)
Par défaut EventEmitter
, s affiche un avertissement si plusieurs 10
écouteurs sont ajoutés pour un événement particulier. Il s’agit d’une valeur par défaut utile qui permet de rechercher des fuites de mémoire. La emitter.setMaxListeners()
méthode permet de modifier la limite pour cette instance spécifique EventEmitter
. La valeur peut être définie sur Infinity
(ou 0
) pour indiquer un nombre illimité d’écouteurs.
Retourne une référence à , afin que les EventEmitter
appels puissent être chaînés.
function setMaxListeners(n: number): ServiceReceiver
Paramètres
- n
-
number
Retours
Hérité 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é de Receiver.__@captureRejectionSymbol@115