Delen via

Client class

  • Referentie
Pakket:
azure-iothub

De IoT Hub-serviceclient wordt gebruikt om te communiceren met apparaten via een Azure IoT-hub. Hiermee kan de SDK-gebruiker:

  • cloud-naar-apparaat verzenden (ook wel opdrachten genoemd) naar apparaten: opdrachten worden in de wachtrij geplaatst op IoT Hub en worden alleen asynchroon geleverd wanneer het apparaat is verbonden. Er kunnen per apparaat slechts 50 opdrachten in de wachtrij worden geplaatst.
  • directe methoden aanroepen op apparaten (die alleen werken als het apparaat momenteel is verbonden: het is een synchrone manier om met het apparaat te communiceren)
  • luisteren naar feedbackberichten die zijn verzonden door apparaten voor eerdere opdrachten.
  • luisteren naar meldingen voor het uploaden van bestanden vanaf apparaten.

Gebruikers moeten nieuwe Client-exemplaren maken door een van de factorymethoden aan te roepen, fromConnectionString of vanSharedAccessSignatureom een IoT Hub-serviceclient te maken.

Uitbreiding

EventEmitter

Overgenomen eigenschappen

captureRejections

Waarde: Booleaanse

Wijzig de standaardoptie captureRejections voor alle nieuwe EventEmitter objecten.
captureRejectionSymbol

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

Zie hoe u een aangepaste rejection handlerschrijft.
defaultMaxListeners

Standaard kunnen maximaal 10 listeners worden geregistreerd voor elke gebeurtenis. Deze limiet kan worden gewijzigd voor afzonderlijke EventEmitter exemplaren met behulp van de methode emitter.setMaxListeners(n). Als u de standaardwaarde voor alleEventEmitter exemplaren wilt wijzigen, kan de eigenschap events.defaultMaxListeners worden gebruikt. Als deze waarde geen positief getal is, wordt er een RangeError gegenereerd.

Wees voorzichtig bij het instellen van de events.defaultMaxListeners omdat de wijziging van invloed is op alleEventEmitter instanties, inclusief de exemplaren die zijn gemaakt voordat de wijziging wordt aangebracht. Het aanroepen van emitter.setMaxListeners(n) heeft echter nog steeds voorrang op events.defaultMaxListeners.

Dit is geen vaste limiet. Met het EventEmitter exemplaar kunnen meer listeners worden toegevoegd, maar wordt er een traceringswaarschuwing naar stderr uitgevoerd die aangeeft dat er een 'mogelijk EventEmitter-geheugenlek' is gedetecteerd. Voor één EventEmitterkunnen de methoden emitter.getMaxListeners() en emitter.setMaxListeners() worden gebruikt om deze waarschuwing tijdelijk te voorkomen:

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));
});

De --trace-warnings opdrachtregelvlag kan worden gebruikt om de stack-trace voor dergelijke waarschuwingen weer te geven.

De verzonden waarschuwing kan worden geïnspecteerd met process.on('warning') en heeft de aanvullende emitter, typeen count eigenschappen, die verwijzen naar de instantie van de gebeurtenisuitzender, respectievelijk de naam van de gebeurtenis en het aantal gekoppelde listeners. De eigenschap name is ingesteld op 'MaxListenersExceededWarning'.
errorMonitor

Dit symbool wordt gebruikt om een listener te installeren voor het alleen controleren van 'error' gebeurtenissen. Listeners die met dit symbool zijn geïnstalleerd, worden aangeroepen voordat de reguliere 'error' listeners worden aangeroepen.

Als u een listener installeert met dit symbool, wordt het gedrag niet gewijzigd zodra een 'error' gebeurtenis wordt verzonden. Daarom loopt het proces nog steeds vast als er geen gewone 'error'-listener is geïnstalleerd.

Methoden

close()
close(IncomingMessageCallback<Disconnected>)

Hiermee sluit u de verbinding met een IoT-hub.
fromConnectionString(string, TransportCtor)

Hiermee maakt u een IoT Hub-serviceclient op basis van de opgegeven verbindingsreeks met behulp van het standaardtransport (Amqp) of de client die is opgegeven in het tweede argument.
fromSharedAccessSignature(string, TransportCtor)

Hiermee maakt u een IoT Hub-serviceclient op basis van de opgegeven Shared Access Signature met behulp van het standaardtransport (Amqp) of de client die is opgegeven in het tweede argument.
fromTokenCredential(string, TokenCredential, TransportCtor)

Hiermee maakt u een IoT Hub-serviceclient van het opgegeven Azure-tokenCredential met behulp van het standaardtransport (Amqp) of de client die is opgegeven in het tweede argument.
getFeedbackReceiver()
getFeedbackReceiver(IncomingMessageCallback<ServiceReceiver>)

Retourneert een AmqpReceiver-object dat gebeurtenissen verzendt wanneer nieuwe feedbackberichten door de client worden ontvangen.
getFileNotificationReceiver()
getFileNotificationReceiver(IncomingMessageCallback<ServiceReceiver>)

Retourneert een AmqpReceiver-object dat gebeurtenissen verzendt wanneer nieuwe meldingen voor het uploaden van bestanden worden ontvangen door de client.
invokeDeviceMethod(string, DeviceMethodParams)
invokeDeviceMethod(string, DeviceMethodParams, IncomingMessageCallback<any>)

Roept een methode aan op een bepaald apparaat of een bepaalde module.
invokeDeviceMethod(string, string, DeviceMethodParams)
invokeDeviceMethod(string, string, DeviceMethodParams, IncomingMessageCallback<any>)
open()
open(IncomingMessageCallback<Connected>)

Hiermee opent u de verbinding met een IoT-hub.
send(string, Message | BufferConvertible)
send(string, Message | BufferConvertible, IncomingMessageCallback<MessageEnqueued>)

Hiermee wordt een bericht naar een apparaat verzonden.
setRetryPolicy(RetryPolicy)

Stel het beleid in dat door de client wordt gebruikt om netwerkbewerkingen opnieuw uit te voeren.

Overgenomen methoden

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

Luistert eenmaal naar de abort gebeurtenis op de opgegeven signal.

Het luisteren naar de abort gebeurtenis bij het afbreken van signalen is onveilig en kan leiden tot bronlekken omdat een andere derde partij met het signaal e.stopImmediatePropagation()kan aanroepen. Helaas kan Node.js dit niet wijzigen omdat deze de webstandaard zou schenden. Bovendien kunt u met de oorspronkelijke API gemakkelijk listeners verwijderen.

Met deze API kunt u veilig AbortSignals in Node.js API's gebruiken door deze twee problemen op te lossen door te luisteren naar de gebeurtenis, zodat stopImmediatePropagation niet verhindert dat de listener wordt uitgevoerd.

Retourneert een wegwerp zodat deze zich gemakkelijker kan afmelden.

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 voor emitter.on(eventName, listener).
emit<K>(string | symbol, AnyRest)

Roept synchroon elk van de listeners aan die zijn geregistreerd voor de gebeurtenis met de naam eventName, in de volgorde waarin ze zijn geregistreerd, waarbij de opgegeven argumenten aan elk item worden doorgegeven.

Retourneert true als de gebeurtenis listeners had, anders false.

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()

Retourneert een matrix met de gebeurtenissen waarvoor de emitter listeners heeft geregistreerd. De waarden in de matrix zijn tekenreeksen of 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<DefaultEventMap> | EventTarget, string | symbol)

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam eventName.

Voor EventEmittergedraagt dit zich precies hetzelfde als het aanroepen van .listeners op de emitter.

Voor EventTargetis dit de enige manier om de gebeurtenislisteners voor het doel van de gebeurtenis op te halen. Dit is handig voor foutopsporing en diagnostische doeleinden.

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()

Retourneert de huidige maximale listenerwaarde voor de EventEmitter die is ingesteld door emitter.setMaxListeners(n) of standaard ingesteld op defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Retourneert de momenteel ingestelde maximale hoeveelheid listeners.

Voor EventEmittergedraagt dit zich precies hetzelfde als het aanroepen van .getMaxListeners op de emitter.

Voor EventTargetis dit de enige manier om de maximale gebeurtenislisteners voor het gebeurtenisdoel op te halen. Als het aantal gebeurtenis-handlers op één EventTarget de maximale set overschrijdt, wordt er een waarschuwing afgedrukt.

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<DefaultEventMap>, string | symbol)

Een klassemethode die het aantal listeners retourneert voor de opgegeven eventName geregistreerd op de opgegeven 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)

Retourneert het aantal listeners dat luistert naar de gebeurtenis met de naam eventName. Als listener wordt opgegeven, wordt geretourneerd hoe vaak de listener wordt gevonden in de lijst met listeners van de gebeurtenis.
listeners<K>(string | symbol)

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam 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 voor 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

Retourneert een AsyncIterator die eventName gebeurtenissen herhaalt. Het zal gooien als de EventEmitter'error'verzendt. Alle listeners worden verwijderd bij het afsluiten van de lus. De value geretourneerd door elke iteratie is een matrix die bestaat uit de gegenereerde gebeurtenisargumenten.

Een AbortSignal kan worden gebruikt om wachten op gebeurtenissen te annuleren:

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());

Gebruik de optie close om een matrix met gebeurtenisnamen op te geven waarmee de iteratie wordt beëindigd:

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)

Hiermee voegt u de functie listener toe aan het einde van de listenersmatrix voor de gebeurtenis met de naam eventName. Er worden geen controles uitgevoerd om te zien of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName doorgeven en listener leiden ertoe dat de listener meerdere keren wordt toegevoegd en aangeroepen.

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

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode emitter.prependListener() kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix.

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)

Hiermee maakt u een Promise die wordt uitgevoerd wanneer de EventEmitter de opgegeven gebeurtenis verzendt of die wordt geweigerd als de EventEmitter'error' verzendt tijdens het wachten. De Promise wordt omgezet met een matrix van alle argumenten die worden verzonden naar de opgegeven gebeurtenis.

Deze methode is opzettelijk algemeen en werkt met het webplatform EventTarget interface, die geen speciale'error' gebeurtenissemantiek heeft en niet luistert naar de 'error' gebeurtenis.

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);
}

De speciale verwerking van de 'error' gebeurtenis wordt alleen gebruikt wanneer events.once() wordt gebruikt om te wachten op een andere gebeurtenis. Als events.once() wordt gebruikt om te wachten op de 'error' gebeurtenis zelf, wordt het beschouwd als een ander soort gebeurtenis zonder speciale verwerking:

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

Een AbortSignal kan worden gebruikt om het wachten op de gebeurtenis te annuleren:

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)

Hiermee voegt u een eenmalige-functie toe voor de gebeurtenis met de naam . De volgende keer dat eventName wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen.

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

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode emitter.prependOnceListener() kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix.

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)

Hiermee voegt u de functie listener toe aan de die begint van de listenersmatrix voor de gebeurtenis met de naam eventName. Er worden geen controles uitgevoerd om te zien of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName doorgeven en listener leiden ertoe dat de listener meerdere keren wordt toegevoegd en aangeroepen.

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

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Hiermee voegt u een eenmaligelistener functie toe voor de gebeurtenis met de naam eventName aan de die begint van de listenersmatrix. De volgende keer dat eventName wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen.

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

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.
rawListeners<K>(string | symbol)

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam eventName, inclusief eventuele wrappers (zoals die zijn gemaakt door .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)

Hiermee verwijdert u alle listeners of de listeners van de opgegeven eventName.

Het is slecht om listeners te verwijderen die ergens anders in de code zijn toegevoegd, met name wanneer het EventEmitter exemplaar is gemaakt door een ander onderdeel of een andere module (bijvoorbeeld sockets of bestandsstromen).

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.
removeListener<K>(string | symbol, (args: any[]) => void)

Hiermee verwijdert u de opgegeven listener uit de listenermatrix voor de gebeurtenis met de naam eventName.

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

removeListener() verwijdert maximaal één exemplaar van een listener uit de listenermatrix. Als er meerdere keren één listener is toegevoegd aan de listenermatrix voor de opgegeven eventName, moet removeListener() meerdere keren worden aangeroepen om elk exemplaar te verwijderen.

Zodra een gebeurtenis is verzonden, worden alle listeners die eraan zijn gekoppeld op het moment van verzenden in volgorde aangeroepen. Dit impliceert dat alle removeListener() of removeAllListeners() aanroepen nadat verzenden en voordat de laatste listener de uitvoering heeft voltooid, deze niet uitemit() worden verwijderd. Volgende gebeurtenissen gedragen zich zoals verwacht.

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

Omdat listeners worden beheerd met behulp van een interne matrix, worden de positieindexen van alle geregistreerde listener-gewijzigd nadat de listener wordt verwijderd. Dit heeft geen invloed op de volgorde waarin listeners worden aangeroepen, maar dit betekent dat kopieën van de listenermatrix die worden geretourneerd door de methode emitter.listeners() opnieuw moeten worden gemaakt.

Wanneer één functie meerdere keren is toegevoegd als handler voor één gebeurtenis (zoals in het onderstaande voorbeeld), verwijdert removeListener() het laatst toegevoegde exemplaar. In het voorbeeld wordt de once('ping') listener verwijderd:

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');

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.
setMaxListeners(number)

Standaard worden EventEmitters een waarschuwing afgedrukt als er meer dan 10 listeners worden toegevoegd voor een bepaalde gebeurtenis. Dit is een nuttige standaardinstelling waarmee geheugenlekken kunnen worden gevonden. Met de methode emitter.setMaxListeners() kan de limiet voor dit specifieke EventEmitter exemplaar worden gewijzigd. De waarde kan worden ingesteld op Infinity (of 0) om een onbeperkt aantal listeners aan te geven.

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

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

setMaxListeners(5, target, emitter);
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Details van overgenomen eigenschap

captureRejections

Waarde: Booleaanse

Wijzig de standaardoptie captureRejections voor alle nieuwe EventEmitter objecten.

static captureRejections: boolean

Waarde van eigenschap

boolean

overgenomen van EventEmitter.captureRejections

captureRejectionSymbol

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

Zie hoe u een aangepaste rejection handlerschrijft.

static captureRejectionSymbol: typeof captureRejectionSymbol

Waarde van eigenschap

typeof captureRejectionSymbol

overgenomen van EventEmitter.captureRejectionSymbol

defaultMaxListeners

Standaard kunnen maximaal 10 listeners worden geregistreerd voor elke gebeurtenis. Deze limiet kan worden gewijzigd voor afzonderlijke EventEmitter exemplaren met behulp van de methode emitter.setMaxListeners(n). Als u de standaardwaarde voor alleEventEmitter exemplaren wilt wijzigen, kan de eigenschap events.defaultMaxListeners worden gebruikt. Als deze waarde geen positief getal is, wordt er een RangeError gegenereerd.

Wees voorzichtig bij het instellen van de events.defaultMaxListeners omdat de wijziging van invloed is op alleEventEmitter instanties, inclusief de exemplaren die zijn gemaakt voordat de wijziging wordt aangebracht. Het aanroepen van emitter.setMaxListeners(n) heeft echter nog steeds voorrang op events.defaultMaxListeners.

Dit is geen vaste limiet. Met het EventEmitter exemplaar kunnen meer listeners worden toegevoegd, maar wordt er een traceringswaarschuwing naar stderr uitgevoerd die aangeeft dat er een 'mogelijk EventEmitter-geheugenlek' is gedetecteerd. Voor één EventEmitterkunnen de methoden emitter.getMaxListeners() en emitter.setMaxListeners() worden gebruikt om deze waarschuwing tijdelijk te voorkomen:

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));
});

De --trace-warnings opdrachtregelvlag kan worden gebruikt om de stack-trace voor dergelijke waarschuwingen weer te geven.

De verzonden waarschuwing kan worden geïnspecteerd met process.on('warning') en heeft de aanvullende emitter, typeen count eigenschappen, die verwijzen naar de instantie van de gebeurtenisuitzender, respectievelijk de naam van de gebeurtenis en het aantal gekoppelde listeners. De eigenschap name is ingesteld op 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Waarde van eigenschap

number

overgenomen van EventEmitter.defaultMaxListeners

errorMonitor

Dit symbool wordt gebruikt om een listener te installeren voor het alleen controleren van 'error' gebeurtenissen. Listeners die met dit symbool zijn geïnstalleerd, worden aangeroepen voordat de reguliere 'error' listeners worden aangeroepen.

Als u een listener installeert met dit symbool, wordt het gedrag niet gewijzigd zodra een 'error' gebeurtenis wordt verzonden. Daarom loopt het proces nog steeds vast als er geen gewone 'error'-listener is geïnstalleerd.

static errorMonitor: typeof errorMonitor

Waarde van eigenschap

typeof errorMonitor

overgenomen van EventEmitter.errorMonitor

Methodedetails

close() 

function close(): Promise<ResultWithIncomingMessage<Disconnected>>

Retouren

Promise<ResultWithIncomingMessage<Disconnected>>

close(IncomingMessageCallback<Disconnected>)

Hiermee sluit u de verbinding met een IoT-hub.

function close(done?: IncomingMessageCallback<Disconnected>)

Parameters

done

IncomingMessageCallback<Disconnected>

De optionele functie die moet worden aangeroepen wanneer de bewerking is voltooid. done wordt een argument foutobject doorgegeven. Dit is null als de bewerking is voltooid.

fromConnectionString(string, TransportCtor)

Hiermee maakt u een IoT Hub-serviceclient op basis van de opgegeven verbindingsreeks met behulp van het standaardtransport (Amqp) of de client die is opgegeven in het tweede argument.

static function fromConnectionString(connStr: string, transportCtor?: TransportCtor): Client

Parameters

connStr

string

Een verbindingsreeks die machtigingen voor apparaatverbinding inkapselt voor een IoT-hub.

transportCtor
TransportCtor

Retouren

Client

fromSharedAccessSignature(string, TransportCtor)

Hiermee maakt u een IoT Hub-serviceclient op basis van de opgegeven Shared Access Signature met behulp van het standaardtransport (Amqp) of de client die is opgegeven in het tweede argument.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor?: TransportCtor): Client

Parameters

sharedAccessSignature

string

Een handtekening voor gedeelde toegang die 'service connect' inkapselt voor een IoT-hub.

transportCtor
TransportCtor

Retouren

Client

fromTokenCredential(string, TokenCredential, TransportCtor)

Hiermee maakt u een IoT Hub-serviceclient van het opgegeven Azure-tokenCredential met behulp van het standaardtransport (Amqp) of de client die is opgegeven in het tweede argument.

static function fromTokenCredential(hostName: string, tokenCredential: TokenCredential, transportCtor?: TransportCtor): Client

Parameters

hostName

string

Hostnaam van de Azure-service.

tokenCredential
TokenCredential

Een Azure TokenCredential die wordt gebruikt om te verifiëren met de Azure-service

transportCtor
TransportCtor

Retouren

Client

getFeedbackReceiver() 

function getFeedbackReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

Retouren

Promise<ResultWithIncomingMessage<ServiceReceiver>>

getFeedbackReceiver(IncomingMessageCallback<ServiceReceiver>)

Retourneert een AmqpReceiver-object dat gebeurtenissen verzendt wanneer nieuwe feedbackberichten door de client worden ontvangen.

function getFeedbackReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Parameters

done

IncomingMessageCallback<ServiceReceiver>

De optionele functie die moet worden aangeroepen wanneer de bewerking is voltooid. done wordt aangeroepen met twee argumenten: een foutobject (kan null zijn) en een AmqpReceiver-object.

getFileNotificationReceiver() 

function getFileNotificationReceiver(): Promise<ResultWithIncomingMessage<ServiceReceiver>>

Retouren

Promise<ResultWithIncomingMessage<ServiceReceiver>>

getFileNotificationReceiver(IncomingMessageCallback<ServiceReceiver>)

Retourneert een AmqpReceiver-object dat gebeurtenissen verzendt wanneer nieuwe meldingen voor het uploaden van bestanden worden ontvangen door de client.

function getFileNotificationReceiver(done?: IncomingMessageCallback<ServiceReceiver>)

Parameters

done

IncomingMessageCallback<ServiceReceiver>

De optionele functie die moet worden aangeroepen wanneer de bewerking is voltooid. done wordt aangeroepen met twee argumenten: een foutobject (kan null zijn) en een AmqpReceiver-object.

invokeDeviceMethod(string, DeviceMethodParams) 

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

Parameters

deviceId

string

methodParams
DeviceMethodParams

Retouren

Promise<ResultWithIncomingMessage<any>>

invokeDeviceMethod(string, DeviceMethodParams, IncomingMessageCallback<any>)

Roept een methode aan op een bepaald apparaat of een bepaalde module.

function invokeDeviceMethod(deviceId: string, methodParams: DeviceMethodParams, done?: IncomingMessageCallback<any>)

Parameters

deviceId

string

De id van een bestaande apparaat-id.

methodParams
DeviceMethodParams
done

IncomingMessageCallback<any>

De optionele callback die moet worden aangeroepen met het resultaat van de uitvoering van de methode.

invokeDeviceMethod(string, string, DeviceMethodParams) 

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams): Promise<ResultWithIncomingMessage<any>>

Parameters

deviceId

string

moduleId

string

methodParams
DeviceMethodParams

Retouren

Promise<ResultWithIncomingMessage<any>>

invokeDeviceMethod(string, string, DeviceMethodParams, IncomingMessageCallback<any>) 

function invokeDeviceMethod(deviceId: string, moduleId: string, methodParams: DeviceMethodParams, done: IncomingMessageCallback<any>)

Parameters

deviceId

string

moduleId

string

methodParams
DeviceMethodParams
done

IncomingMessageCallback<any>

open() 

function open(): Promise<ResultWithIncomingMessage<Connected>>

Retouren

Promise<ResultWithIncomingMessage<Connected>>

open(IncomingMessageCallback<Connected>)

Hiermee opent u de verbinding met een IoT-hub.

function open(done?: IncomingMessageCallback<Connected>)

Parameters

done

IncomingMessageCallback<Connected>

De optionele functie die moet worden aangeroepen wanneer de bewerking is voltooid. done wordt een argument foutobject doorgegeven. Dit is null als de bewerking is voltooid.

send(string, Message | BufferConvertible) 

function send(deviceId: string, message: Message | BufferConvertible): Promise<ResultWithIncomingMessage<MessageEnqueued>>

Parameters

deviceId

string

message

Message | BufferConvertible

Retouren

Promise<ResultWithIncomingMessage<MessageEnqueued>>

send(string, Message | BufferConvertible, IncomingMessageCallback<MessageEnqueued>)

Hiermee wordt een bericht naar een apparaat verzonden.

function send(deviceId: string, message: Message | BufferConvertible, done?: IncomingMessageCallback<MessageEnqueued>)

Parameters

deviceId

string

De id van een bestaande apparaat-id.

message

Message | BufferConvertible

De hoofdtekst van het bericht dat naar het apparaat moet worden verzonden. Als message niet van het type Berichtis, wordt het geconverteerd.

done

IncomingMessageCallback<MessageEnqueued>

De optionele functie die moet worden aangeroepen wanneer de bewerking is voltooid. done wordt aangeroepen met twee argumenten: een foutobject (kan null zijn) en een transportspecifiek antwoordobject dat nuttig is voor logboekregistratie of foutopsporing.

setRetryPolicy(RetryPolicy)

Stel het beleid in dat door de client wordt gebruikt om netwerkbewerkingen opnieuw uit te voeren.

function setRetryPolicy(policy: RetryPolicy)

Parameters

policy

RetryPolicy

beleid dat wordt gebruikt om bewerkingen opnieuw uit te voeren (bijvoorbeeld openen, verzenden, enzovoort). De SDK wordt geleverd met 2 ingebouwde beleidsregels: ExponentialBackoffWithJitter (standaard) en NoRetry (om elke vorm van opnieuw proberen te annuleren). De gebruiker kan ook een eigen object doorgeven zolang er twee methoden worden geïmplementeerd: - shouldRetry(err: Error): boolean : geeft aan of een bewerking opnieuw moet worden geprobeerd op basis van het fouttype - nextRetryTimeout(retryCount: number, beperkt: booleaans): getal: retourneert de tijd die moet worden gewacht (in milliseconden) voordat u het opnieuw probeert op basis van het afgelopen aantal pogingen (retryCount) en het feit dat de fout een beperkingsfout is of niet.

Details overgenomen methode

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

Luistert eenmaal naar de abort gebeurtenis op de opgegeven signal.

Het luisteren naar de abort gebeurtenis bij het afbreken van signalen is onveilig en kan leiden tot bronlekken omdat een andere derde partij met het signaal e.stopImmediatePropagation()kan aanroepen. Helaas kan Node.js dit niet wijzigen omdat deze de webstandaard zou schenden. Bovendien kunt u met de oorspronkelijke API gemakkelijk listeners verwijderen.

Met deze API kunt u veilig AbortSignals in Node.js API's gebruiken door deze twee problemen op te lossen door te luisteren naar de gebeurtenis, zodat stopImmediatePropagation niet verhindert dat de listener wordt uitgevoerd.

Retourneert een wegwerp zodat deze zich gemakkelijker kan afmelden.

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

Parameters

signal

AbortSignal

resource

(event: Event) => void

Retouren

Disposable

Wegwerp dat de abort listener verwijdert.

overgenomen van EventEmitter.addAbortListener

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

Alias voor emitter.on(eventName, listener).

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

Parameters

eventName

string | symbol

listener

(args: any[]) => void

Retouren

Client

overgenomen van EventEmitter.addListener

emit<K>(string | symbol, AnyRest)

Roept synchroon elk van de listeners aan die zijn geregistreerd voor de gebeurtenis met de naam eventName, in de volgorde waarin ze zijn geregistreerd, waarbij de opgegeven argumenten aan elk item worden doorgegeven.

Retourneert true als de gebeurtenis listeners had, anders false.

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

Parameters

eventName

string | symbol

args

AnyRest

Retouren

boolean

overgenomen van EventEmitter.emit

eventNames()

Retourneert een matrix met de gebeurtenissen waarvoor de emitter listeners heeft geregistreerd. De waarden in de matrix zijn tekenreeksen of 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)[]

Retouren

(string | symbol)[]

overgenomen van EventEmitter.eventNames

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

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam eventName.

Voor EventEmittergedraagt dit zich precies hetzelfde als het aanroepen van .listeners op de emitter.

Voor EventTargetis dit de enige manier om de gebeurtenislisteners voor het doel van de gebeurtenis op te halen. Dit is handig voor foutopsporing en diagnostische doeleinden.

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[]

Parameters

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

Retouren

Function[]

overgenomen van EventEmitter.getEventListeners

getMaxListeners()

Retourneert de huidige maximale listenerwaarde voor de EventEmitter die is ingesteld door emitter.setMaxListeners(n) of standaard ingesteld op defaultMaxListeners.

function getMaxListeners(): number

Retouren

number

overgenomen van EventEmitter.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Retourneert de momenteel ingestelde maximale hoeveelheid listeners.

Voor EventEmittergedraagt dit zich precies hetzelfde als het aanroepen van .getMaxListeners op de emitter.

Voor EventTargetis dit de enige manier om de maximale gebeurtenislisteners voor het gebeurtenisdoel op te halen. Als het aantal gebeurtenis-handlers op één EventTarget de maximale set overschrijdt, wordt er een waarschuwing afgedrukt.

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

Parameters

emitter

EventEmitter<DefaultEventMap> | EventTarget

Retouren

number

overgenomen van EventEmitter.getMaxListeners

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Waarschuwing

Deze API is nu afgeschaft.

Since v3.2.0 - Use listenerCount instead.

Een klassemethode die het aantal listeners retourneert voor de opgegeven eventName geregistreerd op de opgegeven 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

Parameters

emitter

EventEmitter<DefaultEventMap>

De emitter om een query uit te voeren

eventName

string | symbol

De gebeurtenisnaam

Retouren

number

overgenomen van EventEmitter.listenerCount

listenerCount<K>(string | symbol, Function)

Retourneert het aantal listeners dat luistert naar de gebeurtenis met de naam eventName. Als listener wordt opgegeven, wordt geretourneerd hoe vaak de listener wordt gevonden in de lijst met listeners van de gebeurtenis.

function listenerCount<K>(eventName: string | symbol, listener?: Function): number

Parameters

eventName

string | symbol

De naam van de gebeurtenis die wordt geluisterd

listener

Function

De functie gebeurtenis-handler

Retouren

number

overgenomen van EventEmitter.listenerCount

listeners<K>(string | symbol)

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam 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[]

Parameters

eventName

string | symbol

Retouren

Function[]

overgenomen van EventEmitter.listeners

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

Alias voor emitter.removeListener().

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

Parameters

eventName

string | symbol

listener

(args: any[]) => void

Retouren

Client

overgenomen van EventEmitter.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

Retourneert een AsyncIterator die eventName gebeurtenissen herhaalt. Het zal gooien als de EventEmitter'error'verzendt. Alle listeners worden verwijderd bij het afsluiten van de lus. De value geretourneerd door elke iteratie is een matrix die bestaat uit de gegenereerde gebeurtenisargumenten.

Een AbortSignal kan worden gebruikt om wachten op gebeurtenissen te annuleren:

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());

Gebruik de optie close om een matrix met gebeurtenisnamen op te geven waarmee de iteratie wordt beëindigd:

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>

Parameters

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

Retouren

AsyncIterator<any[], any, any>

Een AsyncIterator die eventName gebeurtenissen herhaalt die door de emitter zijn verzonden

overgenomen van EventEmitter.on

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

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

Parameters

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

Retouren

AsyncIterator<any[], any, any>

overgenomen van EventEmitter.on

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

Hiermee voegt u de functie listener toe aan het einde van de listenersmatrix voor de gebeurtenis met de naam eventName. Er worden geen controles uitgevoerd om te zien of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName doorgeven en listener leiden ertoe dat de listener meerdere keren wordt toegevoegd en aangeroepen.

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

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode emitter.prependListener() kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix.

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

Parameters

eventName

string | symbol

De naam van de gebeurtenis.

listener

(args: any[]) => void

De callback-functie

Retouren

Client

overgenomen van EventEmitter.on

once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

Hiermee maakt u een Promise die wordt uitgevoerd wanneer de EventEmitter de opgegeven gebeurtenis verzendt of die wordt geweigerd als de EventEmitter'error' verzendt tijdens het wachten. De Promise wordt omgezet met een matrix van alle argumenten die worden verzonden naar de opgegeven gebeurtenis.

Deze methode is opzettelijk algemeen en werkt met het webplatform EventTarget interface, die geen speciale'error' gebeurtenissemantiek heeft en niet luistert naar de 'error' gebeurtenis.

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);
}

De speciale verwerking van de 'error' gebeurtenis wordt alleen gebruikt wanneer events.once() wordt gebruikt om te wachten op een andere gebeurtenis. Als events.once() wordt gebruikt om te wachten op de 'error' gebeurtenis zelf, wordt het beschouwd als een ander soort gebeurtenis zonder speciale verwerking:

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

Een AbortSignal kan worden gebruikt om het wachten op de gebeurtenis te annuleren:

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[]>

Parameters

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

Retouren

Promise<any[]>

overgenomen van EventEmitter.once

once(EventTarget, string, StaticEventEmitterOptions) 

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

Parameters

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

Retouren

Promise<any[]>

overgenomen van EventEmitter.once

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

Hiermee voegt u een eenmalige-functie toe voor de gebeurtenis met de naam . De volgende keer dat eventName wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen.

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

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

Gebeurtenislisteners worden standaard aangeroepen in de volgorde waarin ze worden toegevoegd. De methode emitter.prependOnceListener() kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listenersmatrix.

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

Parameters

eventName

string | symbol

De naam van de gebeurtenis.

listener

(args: any[]) => void

De callback-functie

Retouren

Client

overgenomen van EventEmitter.once

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

Hiermee voegt u de functie listener toe aan de die begint van de listenersmatrix voor de gebeurtenis met de naam eventName. Er worden geen controles uitgevoerd om te zien of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName doorgeven en listener leiden ertoe dat de listener meerdere keren wordt toegevoegd en aangeroepen.

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

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

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

Parameters

eventName

string | symbol

De naam van de gebeurtenis.

listener

(args: any[]) => void

De callback-functie

Retouren

Client

overgenomen van EventEmitter.prependListener

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

Hiermee voegt u een eenmaligelistener functie toe voor de gebeurtenis met de naam eventName aan de die begint van de listenersmatrix. De volgende keer dat eventName wordt geactiveerd, wordt deze listener verwijderd en vervolgens aangeroepen.

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

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

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

Parameters

eventName

string | symbol

De naam van de gebeurtenis.

listener

(args: any[]) => void

De callback-functie

Retouren

Client

overgenomen van EventEmitter.prependOnceListener

rawListeners<K>(string | symbol)

Retourneert een kopie van de matrix van listeners voor de gebeurtenis met de naam eventName, inclusief eventuele wrappers (zoals die zijn gemaakt door .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[]

Parameters

eventName

string | symbol

Retouren

Function[]

overgenomen van EventEmitter.rawListeners

removeAllListeners(string | symbol)

Hiermee verwijdert u alle listeners of de listeners van de opgegeven eventName.

Het is slecht om listeners te verwijderen die ergens anders in de code zijn toegevoegd, met name wanneer het EventEmitter exemplaar is gemaakt door een ander onderdeel of een andere module (bijvoorbeeld sockets of bestandsstromen).

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

function removeAllListeners(eventName?: string | symbol): Client

Parameters

eventName

string | symbol

Retouren

Client

overgenomen van EventEmitter.removeAllListeners

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

Hiermee verwijdert u de opgegeven listener uit de listenermatrix voor de gebeurtenis met de naam eventName.

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

removeListener() verwijdert maximaal één exemplaar van een listener uit de listenermatrix. Als er meerdere keren één listener is toegevoegd aan de listenermatrix voor de opgegeven eventName, moet removeListener() meerdere keren worden aangeroepen om elk exemplaar te verwijderen.

Zodra een gebeurtenis is verzonden, worden alle listeners die eraan zijn gekoppeld op het moment van verzenden in volgorde aangeroepen. Dit impliceert dat alle removeListener() of removeAllListeners() aanroepen nadat verzenden en voordat de laatste listener de uitvoering heeft voltooid, deze niet uitemit() worden verwijderd. Volgende gebeurtenissen gedragen zich zoals verwacht.

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

Omdat listeners worden beheerd met behulp van een interne matrix, worden de positieindexen van alle geregistreerde listener-gewijzigd nadat de listener wordt verwijderd. Dit heeft geen invloed op de volgorde waarin listeners worden aangeroepen, maar dit betekent dat kopieën van de listenermatrix die worden geretourneerd door de methode emitter.listeners() opnieuw moeten worden gemaakt.

Wanneer één functie meerdere keren is toegevoegd als handler voor één gebeurtenis (zoals in het onderstaande voorbeeld), verwijdert removeListener() het laatst toegevoegde exemplaar. In het voorbeeld wordt de once('ping') listener verwijderd:

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');

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

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

Parameters

eventName

string | symbol

listener

(args: any[]) => void

Retouren

Client

overgenomen van EventEmitter.removeListener

setMaxListeners(number)

Standaard worden EventEmitters een waarschuwing afgedrukt als er meer dan 10 listeners worden toegevoegd voor een bepaalde gebeurtenis. Dit is een nuttige standaardinstelling waarmee geheugenlekken kunnen worden gevonden. Met de methode emitter.setMaxListeners() kan de limiet voor dit specifieke EventEmitter exemplaar worden gewijzigd. De waarde kan worden ingesteld op Infinity (of 0) om een onbeperkt aantal listeners aan te geven.

Retourneert een verwijzing naar de EventEmitter, zodat aanroepen kunnen worden gekoppeld.

function setMaxListeners(n: number): Client

Parameters

n

number

Retouren

Client

overgenomen van EventEmitter.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)[])

Parameters

n

number

Een niet-negatief getal. Het maximum aantal listeners per EventTarget gebeurtenis.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

Nul of meer exemplaren van {EventTarget} of {EventEmitter}. Als er geen items zijn opgegeven, wordt n ingesteld als de standaardlimiet voor alle nieuw gemaakte objecten {EventTarget} en {EventEmitter}.

overgenomen van EventEmitter.setMaxListeners

[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest) 

function [captureRejectionSymbol]<K>(error: Error, event: string | symbol, args: AnyRest)

Parameters

error

Error

event

string | symbol

args

AnyRest

overgenomen van EventEmitter.__@captureRejectionSymbol@118