Partager via

Amqp class

  • Référence
Paquet:
azure-iothub

Classe de transport utilisée par le client de service pour se connecter au hub Azure IoT à l’aide du protocole AMQP via un socket SÉCURISÉ (TLS). Cette classe ne doit pas être utilisée directement et être passée à l’une des méthodes de fabrique Client : fromConnectionString ou fromSharedAccessSignature.

Extends

EventEmitter

Propriétés héritées

captureRejections

Valeur : booléen

Modifiez l’option de captureRejections par défaut sur tous les nouveaux objets EventEmitter.
captureRejectionSymbol

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

Découvrez comment écrire un rejection handlerpersonnalisé.
defaultMaxListeners

Par défaut, un maximum d’écouteurs 10 peuvent être inscrits pour n’importe quel événement unique. Cette limite peut être modifiée pour les instances de EventEmitter individuelles à l’aide de la méthode emitter.setMaxListeners(n). Pour modifier la valeur par défaut pour toutes les instancesEventEmitter, la propriété events.defaultMaxListeners peut être utilisée. Si cette valeur n’est pas un nombre positif, une RangeError est levée.

Prenez attention lors de la définition de la events.defaultMaxListeners, car la modification affecte toutes les instancesEventEmitter, y compris celles créées avant la modification. Toutefois, l’appel emitter.setMaxListeners(n) a toujours la priorité sur events.defaultMaxListeners.

Ce n’est pas une limite difficile. L’instance de EventEmitter permettra à d’autres écouteurs d’être ajoutés, mais génère un avertissement de trace à stderr indiquant qu’une « fuite de mémoire EventEmitter possible » a été détectée. Pour n’importe quel EventEmitterunique, les méthodes emitter.getMaxListeners() et emitter.setMaxListeners() peuvent être utilisées pour éviter temporairement cet avertissement :

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

L’indicateur de ligne de commande --trace-warnings peut être utilisé pour afficher la trace de pile pour ces avertissements.

L’avertissement émis peut être inspecté avec process.on('warning') et aura les emitter, typeet les propriétés count supplémentaires, faisant référence à l’instance de l’émetteur d’événement, au nom de l’événement et au nombre d’écouteurs attachés, respectivement. Sa propriété name est définie sur 'MaxListenersExceededWarning'.
errorMonitor

Ce symbole doit être utilisé pour installer un écouteur pour surveiller uniquement les événements 'error'. Les écouteurs installés à l’aide de ce symbole sont appelés avant que les écouteurs standard 'error' soient appelés.

L’installation d’un écouteur à l’aide de ce symbole ne modifie pas le comportement une fois qu’un événement 'error' est émis. Par conséquent, le processus se bloque toujours si aucun écouteur de 'error' standard n’est installé.

Méthodes héritées

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

Écoute une fois l’événement abort sur la signalfournie.

L’écoute de l’événement abort sur les signaux d’abandon est dangereux et peut entraîner des fuites de ressources, car un autre tiers avec le signal peut appeler e.stopImmediatePropagation(). Malheureusement, Node.js ne peut pas changer cette situation, car elle violerait la norme web. En outre, l’API d’origine facilite l’oubli de supprimer les écouteurs.

Cette API permet d’utiliser en toute sécurité des AbortSignals dans Node.js API en résolvant ces deux problèmes en écoutant l’événement de sorte que stopImmediatePropagation n’empêche pas l’écouteur d’être en cours d’exécution.

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

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}
addListener<EventName>(EventName, Listener<{}, EventName>)

Alias pour emitter.on(eventName, listener).
addListener<EventName>(EventName, Listener<{}, EventName>)
emit<EventName>(EventName, Args<{}, EventName>)

Appelle de manière synchrone chacun des écouteurs inscrits pour l’événement nommé eventName, dans l’ordre dans lequel ils ont été inscrits, en passant les arguments fournis à chacun d’eux.

Retourne true si l’événement avait des écouteurs, false sinon.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener
emit<EventName>(EventName, Args<{}, EventName>)
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) ]
getEventListeners(EventEmitter<{}> | EventTarget, string | symbol)
getEventListeners<Events, EventName>(EventEmitter<Events>, EventName)

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

Pour EventEmitters, cela se comporte exactement comme l’appel de .listeners sur l’émetteur.

Pour EventTargets, il s’agit de la seule façon d’obtenir les écouteurs d’événements pour la cible d’événement. Cela est utile à des fins de débogage et de diagnostic.

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

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}
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.
getMaxListeners(EventEmitter<{}> | EventTarget)

Retourne la quantité maximale actuellement définie d’écouteurs.

Pour EventEmitters, cela se comporte exactement comme l’appel de .getMaxListeners sur l’émetteur.

Pour EventTargets, il s’agit de la seule façon d’obtenir les écouteurs d’événements max pour la cible d’événement. Si le nombre de gestionnaires d’événements sur un seul EventTarget dépasse le nombre maximal défini, EventTarget affiche un avertissement.

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

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}
listenerCount(EventEmitter<{}>, string | symbol)

Méthode de classe qui retourne le nombre d’écouteurs pour la eventName donnée inscrite sur le emitterdonné.

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
listenerCount<EventName>(EventName, Listener<{}, EventName>)

Retourne le nombre d’écouteurs à l’écoute de l’événement nommé eventName. Si listener est fourni, il retourne le nombre de fois où l’écouteur est trouvé dans la liste des écouteurs de l’événement.
listenerCount<EventName>(EventName, Listener<{}, EventName>)
listenerCount<Events, EventName>(EventEmitter<Events>, EventName)

Méthode de classe qui retourne le nombre d’écouteurs pour la eventName donnée inscrite sur le emitterdonné.

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
listeners<EventName>(EventName)

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

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
listeners<EventName>(EventName)
off<EventName>(EventName, Listener<{}, EventName>)

Alias pour emitter.removeListener().
off<EventName>(EventName, Listener<{}, EventName>)
on(EventEmitter<{}>, string | symbol, StaticEventEmitterIteratorOptions)
on(EventTarget, string, StaticEventEmitterIteratorOptions)
on<EventName>(EventName, Listener<{}, EventName>)

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

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

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

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode emitter.prependListener() peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
on<EventName>(EventName, Listener<{}, EventName>)
on<Events, EventName>(EventEmitter<Events>, EventName, StaticEventEmitterIteratorOptions) 
import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

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

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

Retourne un AsyncIterator qui itère eventName événements. Elle lève si le EventEmitter émet 'error'. Elle supprime tous les écouteurs lors de la sortie de la boucle. La value retournée par chaque itération est un tableau composé des arguments d’événement émis.

Une AbortSignal peut être utilisée pour annuler l’attente sur les événements :

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

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

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

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

process.nextTick(() => ac.abort());

Utilisez l’option close pour spécifier un tableau de noms d’événements qui met fin à l’itération :

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

const ee = new EventEmitter();

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

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
once(EventEmitter<{}>, string | symbol, StaticEventEmitterOptions)
once(EventTarget, string, StaticEventEmitterOptions)
once<EventName>(EventName, Listener<{}, EventName>)

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

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

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

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode emitter.prependOnceListener() peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
once<EventName>(EventName, Listener<{}, EventName>)
once<Events, EventName>(EventEmitter<Events>, EventName, StaticEventEmitterOptions)

Crée un Promise qui est rempli lorsque le EventEmitter émet l’événement donné ou qui est rejeté si le EventEmitter émet 'error' en attendant. Le Promise est résolu avec un tableau de tous les arguments émis à l’événement donné.

Cette méthode est intentionnellement générique et fonctionne avec la plateforme web l’interface EventTarget, qui n’a aucune sémantique d’événement'error' spéciale et n’écoute pas l’événement 'error'.

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

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

La gestion spéciale de l’événement 'error' est utilisée uniquement lorsque events.once() est utilisé pour attendre un autre événement. Si events.once() est utilisé pour attendre l’événementerror' lui-même, il est traité comme n’importe quel autre type d’événement sans gestion spéciale :

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

const ee = new EventEmitter();

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

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

// Prints: ok boom

Une AbortSignal peut être utilisée pour annuler l’attente de l’événement :

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

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
prependListener<EventName>(EventName, Listener<{}, EventName>)

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

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

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.
prependListener<EventName>(EventName, Listener<{}, EventName>)
prependOnceListener<EventName>(EventName, Listener<{}, EventName>)

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

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

Retourne une référence au EventEmitter, afin que les appels puissent être chaînés.
prependOnceListener<EventName>(EventName, Listener<{}, EventName>)
rawListeners<EventName>(EventName)

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName, y compris les wrappers (tels que ceux créés par .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');
rawListeners<EventName>(EventName)
removeAllListeners<EventName>(EventName)

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.
removeAllListeners<EventName>(EventName)
removeListener<EventName>(EventName, Listener<{}, EventName>)

Supprime le listener spécifié du tableau d’écouteurs pour l’événement nommé eventName.

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

removeListener() supprimera, au plus, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le 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.
removeListener<EventName>(EventName, Listener<{}, EventName>)
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.
setMaxListeners(number, (EventEmitter<{}> | EventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

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

setMaxListeners(5, target, emitter);
[captureRejectionSymbol](Error, string | symbol, any[])
[captureRejectionSymbol]<EventName>(Error, EventName, Args<{}, EventName>)

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

captureRejections

Valeur : booléen

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

static captureRejections: boolean

Valeur de propriété

boolean

héritée de EventEmitter.captureRejections

captureRejectionSymbol

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

Découvrez comment écrire un rejection handlerpersonnalisé.

static captureRejectionSymbol: typeof captureRejectionSymbol

Valeur de propriété

typeof captureRejectionSymbol

héritée de EventEmitter.captureRejectionSymbol

defaultMaxListeners

Par défaut, un maximum d’écouteurs 10 peuvent être inscrits pour n’importe quel événement unique. Cette limite peut être modifiée pour les instances de EventEmitter individuelles à l’aide de la méthode emitter.setMaxListeners(n). Pour modifier la valeur par défaut pour toutes les instancesEventEmitter, la propriété events.defaultMaxListeners peut être utilisée. Si cette valeur n’est pas un nombre positif, une RangeError est levée.

Prenez attention lors de la définition de la events.defaultMaxListeners, car la modification affecte toutes les instancesEventEmitter, y compris celles créées avant la modification. Toutefois, l’appel emitter.setMaxListeners(n) a toujours la priorité sur events.defaultMaxListeners.

Ce n’est pas une limite difficile. L’instance de EventEmitter permettra à d’autres écouteurs d’être ajoutés, mais génère un avertissement de trace à stderr indiquant qu’une « fuite de mémoire EventEmitter possible » a été détectée. Pour n’importe quel EventEmitterunique, les méthodes emitter.getMaxListeners() et emitter.setMaxListeners() peuvent être utilisées pour éviter temporairement cet avertissement :

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

L’indicateur de ligne de commande --trace-warnings peut être utilisé pour afficher la trace de pile pour ces avertissements.

L’avertissement émis peut être inspecté avec process.on('warning') et aura les emitter, typeet les propriétés count supplémentaires, faisant référence à l’instance de l’émetteur d’événement, au nom de l’événement et au nombre d’écouteurs attachés, respectivement. Sa propriété name est définie sur 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Valeur de propriété

number

héritée de EventEmitter.defaultMaxListeners

errorMonitor

Ce symbole doit être utilisé pour installer un écouteur pour surveiller uniquement les événements 'error'. Les écouteurs installés à l’aide de ce symbole sont appelés avant que les écouteurs standard 'error' soient appelés.

L’installation d’un écouteur à l’aide de ce symbole ne modifie pas le comportement une fois qu’un événement 'error' est émis. Par conséquent, le processus se bloque toujours si aucun écouteur de 'error' standard n’est installé.

static errorMonitor: typeof errorMonitor

Valeur de propriété

typeof errorMonitor

héritée de EventEmitter.errorMonitor

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

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

Écoute une fois l’événement abort sur la signalfournie.

L’écoute de l’événement abort sur les signaux d’abandon est dangereux et peut entraîner des fuites de ressources, car un autre tiers avec le signal peut appeler e.stopImmediatePropagation(). Malheureusement, Node.js ne peut pas changer cette situation, car elle violerait la norme web. En outre, l’API d’origine facilite l’oubli de supprimer les écouteurs.

Cette API permet d’utiliser en toute sécurité des AbortSignals dans Node.js API en résolvant ces deux problèmes en écoutant l’événement de sorte que stopImmediatePropagation n’empêche pas l’écouteur d’être en cours d’exécution.

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

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}

static function addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable

Paramètres

signal

AbortSignal

resource

(event: Event) => void

Retours

Disposable

Jetable qui supprime l’écouteur abort.

héritée de EventEmitter.addAbortListener

addListener<EventName>(EventName, Listener<{}, EventName>)

Alias pour emitter.on(eventName, listener).

function addListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.addListener

addListener<EventName>(EventName, Listener<{}, EventName>) 

function addListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.addListener

emit<EventName>(EventName, Args<{}, EventName>)

Appelle de manière synchrone chacun des écouteurs inscrits pour l’événement nommé eventName, dans l’ordre dans lequel ils ont été inscrits, en passant les arguments fournis à chacun d’eux.

Retourne true si l’événement avait des écouteurs, false sinon.

import { EventEmitter } from 'node:events';
const myEmitter = new EventEmitter();

// First listener
myEmitter.on('event', function firstListener() {
  console.log('Helloooo! first listener');
});
// Second listener
myEmitter.on('event', function secondListener(arg1, arg2) {
  console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
});
// Third listener
myEmitter.on('event', function thirdListener(...args) {
  const parameters = args.join(', ');
  console.log(`event with parameters ${parameters} in third listener`);
});

console.log(myEmitter.listeners('event'));

myEmitter.emit('event', 1, 2, 3, 4, 5);

// Prints:
// [
//   [Function: firstListener],
//   [Function: secondListener],
//   [Function: thirdListener]
// ]
// Helloooo! first listener
// event with parameters 1, 2 in second listener
// event with parameters 1, 2, 3, 4, 5 in third listener

function emit<EventName>(eventName: EventName, args: Args<{}, EventName>): boolean

Paramètres

eventName

EventName

args

Args<{}, EventName>

Retours

boolean

héritée de EventEmitter.emit

emit<EventName>(EventName, Args<{}, EventName>) 

function emit<EventName>(eventName: EventName, args: Args<{}, EventName>): boolean

Paramètres

eventName

EventName

args

Args<{}, EventName>

Retours

boolean

héritée de EventEmitter.emit

eventNames()

Retourne un tableau répertoriant les événements pour lesquels l’émetteur a enregistré des écouteurs. Les valeurs du tableau sont des chaînes ou des 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 EventEmitter.eventNames

getEventListeners(EventEmitter<{}> | EventTarget, string | symbol) 

static function getEventListeners(emitter: EventEmitter<{}> | EventTarget, name: string | symbol): Function[]

Paramètres

emitter

EventEmitter<{}> | EventTarget

name

string | symbol

Retours

Function[]

héritée de EventEmitter.getEventListeners

getEventListeners<Events, EventName>(EventEmitter<Events>, EventName)

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

Pour EventEmitters, cela se comporte exactement comme l’appel de .listeners sur l’émetteur.

Pour EventTargets, il s’agit de la seule façon d’obtenir les écouteurs d’événements pour la cible d’événement. Cela est utile à des fins de débogage et de diagnostic.

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

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

static function getEventListeners<Events, EventName>(emitter: EventEmitter<Events>, name: EventName): Listener<Events, EventName>[]

Paramètres

emitter

EventEmitter<Events>

name

EventName

Retours

Listener<Events, EventName>[]

héritée de EventEmitter.getEventListeners

getMaxListeners()

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

function getMaxListeners(): number

Retours

number

héritée de EventEmitter.getMaxListeners

getMaxListeners(EventEmitter<{}> | EventTarget)

Retourne la quantité maximale actuellement définie d’écouteurs.

Pour EventEmitters, cela se comporte exactement comme l’appel de .getMaxListeners sur l’émetteur.

Pour EventTargets, il s’agit de la seule façon d’obtenir les écouteurs d’événements max pour la cible d’événement. Si le nombre de gestionnaires d’événements sur un seul EventTarget dépasse le nombre maximal défini, EventTarget affiche un avertissement.

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

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}

static function getMaxListeners(emitter: EventEmitter<{}> | EventTarget): number

Paramètres

emitter

EventEmitter<{}> | EventTarget

Retours

number

héritée de EventEmitter.getMaxListeners

listenerCount(EventEmitter<{}>, string | symbol)

Avertissement

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

Since v3.2.0 - Use listenerCount instead.

Méthode de classe qui retourne le nombre d’écouteurs pour la eventName donnée inscrite sur le emitterdonné.

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

static function listenerCount(emitter: EventEmitter<{}>, eventName: string | symbol): number

Paramètres

emitter

EventEmitter<{}>

Émetteur à interroger

eventName

string | symbol

Nom de l’événement

Retours

number

héritée de EventEmitter.listenerCount

listenerCount<EventName>(EventName, Listener<{}, EventName>)

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

function listenerCount<EventName>(eventName: EventName, listener?: Listener<{}, EventName>): number

Paramètres

eventName

EventName

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

listener

Listener<{}, EventName>

Fonction du gestionnaire d’événements

Retours

number

héritée de EventEmitter.listenerCount

listenerCount<EventName>(EventName, Listener<{}, EventName>) 

function listenerCount<EventName>(eventName: EventName, listener?: Listener<{}, EventName>): number

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

number

héritée de EventEmitter.listenerCount

listenerCount<Events, EventName>(EventEmitter<Events>, EventName)

Avertissement

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

Since v3.2.0 - Use listenerCount instead.

Méthode de classe qui retourne le nombre d’écouteurs pour la eventName donnée inscrite sur le emitterdonné.

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

static function listenerCount<Events, EventName>(emitter: EventEmitter<Events>, eventName: EventName): number

Paramètres

emitter

EventEmitter<Events>

Émetteur à interroger

eventName

EventName

Nom de l’événement

Retours

number

héritée de EventEmitter.listenerCount

listeners<EventName>(EventName)

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

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]

function listeners<EventName>(eventName: EventName): Listener<{}, EventName>[]

Paramètres

eventName

EventName

Retours

Listener<{}, EventName>[]

héritée de EventEmitter.listeners

listeners<EventName>(EventName) 

function listeners<EventName>(eventName: EventName): Listener<{}, EventName>[]

Paramètres

eventName

EventName

Retours

Listener<{}, EventName>[]

héritée de EventEmitter.listeners

off<EventName>(EventName, Listener<{}, EventName>)

Alias pour emitter.removeListener().

function off<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.off

off<EventName>(EventName, Listener<{}, EventName>) 

function off<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.off

on(EventEmitter<{}>, string | symbol, StaticEventEmitterIteratorOptions) 

static function on(emitter: EventEmitter<{}>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Paramètres

emitter

EventEmitter<{}>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

Retours

AsyncIterator<any[], any, any>

héritée de EventEmitter.on

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

static function on(emitter: EventTarget, eventName: string, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Paramètres

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

Retours

AsyncIterator<any[], any, any>

héritée de EventEmitter.on

on<EventName>(EventName, Listener<{}, EventName>)

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

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

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

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode emitter.prependListener() peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function on<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

Nom de l’événement.

listener

Listener<{}, EventName>

Fonction de rappel

Retours

Amqp

héritée de EventEmitter.on

on<EventName>(EventName, Listener<{}, EventName>) 

function on<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.on

on<Events, EventName>(EventEmitter<Events>, EventName, StaticEventEmitterIteratorOptions) 

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

const ee = new EventEmitter();

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

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

Retourne un AsyncIterator qui itère eventName événements. Elle lève si le EventEmitter émet 'error'. Elle supprime tous les écouteurs lors de la sortie de la boucle. La value retournée par chaque itération est un tableau composé des arguments d’événement émis.

Une AbortSignal peut être utilisée pour annuler l’attente sur les événements :

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

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

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

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

process.nextTick(() => ac.abort());

Utilisez l’option close pour spécifier un tableau de noms d’événements qui met fin à l’itération :

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

const ee = new EventEmitter();

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

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on<Events, EventName>(emitter: EventEmitter<Events>, eventName: EventName, options?: StaticEventEmitterIteratorOptions): AsyncIterator<Args<Events, EventName>, any, any>

Paramètres

emitter

EventEmitter<Events>

eventName

EventName

options

StaticEventEmitterIteratorOptions

Retours

AsyncIterator<Args<Events, EventName>, any, any>

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

héritée de EventEmitter.on

once(EventEmitter<{}>, string | symbol, StaticEventEmitterOptions) 

static function once(emitter: EventEmitter<{}>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>

Paramètres

emitter

EventEmitter<{}>

eventName

string | symbol

options

StaticEventEmitterOptions

Retours

Promise<any[]>

héritée de EventEmitter.once

once(EventTarget, string, StaticEventEmitterOptions) 

static function once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>

Paramètres

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

Retours

Promise<any[]>

héritée de EventEmitter.once

once<EventName>(EventName, Listener<{}, EventName>)

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

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

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

Par défaut, les écouteurs d’événements sont appelés dans l’ordre dans lequel ils sont ajoutés. La méthode emitter.prependOnceListener() peut être utilisée comme alternative pour ajouter l’écouteur d’événements au début du tableau d’écouteurs.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

function once<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

Nom de l’événement.

listener

Listener<{}, EventName>

Fonction de rappel

Retours

Amqp

héritée de EventEmitter.once

once<EventName>(EventName, Listener<{}, EventName>) 

function once<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.once

once<Events, EventName>(EventEmitter<Events>, EventName, StaticEventEmitterOptions)

Crée un Promise qui est rempli lorsque le EventEmitter émet l’événement donné ou qui est rejeté si le EventEmitter émet 'error' en attendant. Le Promise est résolu avec un tableau de tous les arguments émis à l’événement donné.

Cette méthode est intentionnellement générique et fonctionne avec la plateforme web l’interface EventTarget, qui n’a aucune sémantique d’événement'error' spéciale et n’écoute pas l’événement 'error'.

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

const ee = new EventEmitter();

process.nextTick(() => {
  ee.emit('myevent', 42);
});

const [value] = await once(ee, 'myevent');
console.log(value);

const err = new Error('kaboom');
process.nextTick(() => {
  ee.emit('error', err);
});

try {
  await once(ee, 'myevent');
} catch (err) {
  console.error('error happened', err);
}

La gestion spéciale de l’événement 'error' est utilisée uniquement lorsque events.once() est utilisé pour attendre un autre événement. Si events.once() est utilisé pour attendre l’événementerror' lui-même, il est traité comme n’importe quel autre type d’événement sans gestion spéciale :

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

const ee = new EventEmitter();

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

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

// Prints: ok boom

Une AbortSignal peut être utilisée pour annuler l’attente de l’événement :

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

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

static function once<Events, EventName>(emitter: EventEmitter<Events>, eventName: EventName, options?: StaticEventEmitterOptions): Promise<Args<Events, EventName>>

Paramètres

emitter

EventEmitter<Events>

eventName

EventName

options

StaticEventEmitterOptions

Retours

Promise<Args<Events, EventName>>

héritée de EventEmitter.once

prependListener<EventName>(EventName, Listener<{}, EventName>)

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

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

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

function prependListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

Nom de l’événement.

listener

Listener<{}, EventName>

Fonction de rappel

Retours

Amqp

héritée de EventEmitter.prependListener

prependListener<EventName>(EventName, Listener<{}, EventName>) 

function prependListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.prependListener

prependOnceListener<EventName>(EventName, Listener<{}, EventName>)

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

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

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

function prependOnceListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

Nom de l’événement.

listener

Listener<{}, EventName>

Fonction de rappel

Retours

Amqp

héritée de EventEmitter.prependOnceListener

prependOnceListener<EventName>(EventName, Listener<{}, EventName>) 

function prependOnceListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.prependOnceListener

rawListeners<EventName>(EventName)

Retourne une copie du tableau d’écouteurs pour l’événement nommé eventName, y compris les wrappers (tels que ceux créés par .once()).

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.once('log', () => console.log('log once'));

// Returns a new Array with a function `onceWrapper` which has a property
// `listener` which contains the original listener bound above
const listeners = emitter.rawListeners('log');
const logFnWrapper = listeners[0];

// Logs "log once" to the console and does not unbind the `once` event
logFnWrapper.listener();

// Logs "log once" to the console and removes the listener
logFnWrapper();

emitter.on('log', () => console.log('log persistently'));
// Will return a new Array with a single function bound by `.on()` above
const newListeners = emitter.rawListeners('log');

// Logs "log persistently" twice
newListeners[0]();
emitter.emit('log');

function rawListeners<EventName>(eventName: EventName): Listener<{}, EventName>[]

Paramètres

eventName

EventName

Retours

Listener<{}, EventName>[]

héritée de EventEmitter.rawListeners

rawListeners<EventName>(EventName) 

function rawListeners<EventName>(eventName: EventName): Listener<{}, EventName>[]

Paramètres

eventName

EventName

Retours

Listener<{}, EventName>[]

héritée de EventEmitter.rawListeners

removeAllListeners<EventName>(EventName)

Supprime tous les écouteurs, ou ceux de la 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>(eventName: EventName): Amqp

Paramètres

eventName

EventName

Retours

Amqp

héritée de EventEmitter.removeAllListeners

removeAllListeners<EventName>(EventName) 

function removeAllListeners<EventName>(eventName?: EventName): Amqp

Paramètres

eventName

EventName

Retours

Amqp

héritée de EventEmitter.removeAllListeners

removeListener<EventName>(EventName, Listener<{}, EventName>)

Supprime le listener spécifié du tableau d’écouteurs pour l’événement nommé eventName.

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

removeListener() supprimera, au plus, une instance d’un écouteur du tableau d’écouteurs. Si un écouteur unique a été ajouté plusieurs fois au tableau d’écouteurs pour le 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<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.removeListener

removeListener<EventName>(EventName, Listener<{}, EventName>) 

function removeListener<EventName>(eventName: EventName, listener: Listener<{}, EventName>): Amqp

Paramètres

eventName

EventName

listener

Listener<{}, EventName>

Retours

Amqp

héritée de EventEmitter.removeListener

setMaxListeners(number)

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

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

function setMaxListeners(n: number): Amqp

Paramètres

n

number

Retours

Amqp

héritée de EventEmitter.setMaxListeners

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

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

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

setMaxListeners(5, target, emitter);

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

Paramètres

n

number

Nombre non négatif. Nombre maximal d’écouteurs par événement EventTarget.

eventTargets

(EventEmitter<{}> | EventTarget)[]

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

héritée de EventEmitter.setMaxListeners

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

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

Paramètres

error

Error

event

string | symbol

args

any[]

héritée de EventEmitter.__@captureRejectionSymbol@155

[captureRejectionSymbol]<EventName>(Error, EventName, Args<{}, EventName>) 

function [captureRejectionSymbol]<EventName>(error: Error, event: EventName, args: Args<{}, EventName>)

Paramètres

error

Error

event

EventName

args

Args<{}, EventName>

héritée de EventEmitter.__@captureRejectionSymbol@155