Share via

Client class

  • Referentie
Pakket:
azure-iot-device

IoT Hub apparaatclient die wordt gebruikt om een apparaat te verbinden met een Azure IoT-hub.

Gebruikers van de SDK moeten een van de factorymethoden aanroepen, fromConnectionString of fromSharedAccessSignature om een IoT Hub apparaatclient te maken.

Extends

InternalClient

Constructors

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface)

Overgenomen eigenschappen

captureRejections

Waarde: booleaanse waarde

Wijzig de standaardoptie captureRejections voor alle nieuwe EventEmitter objecten.
captureRejectionSymbol

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

Meer informatie over het schrijven van een aangepaste rejection handler.
defaultMaxListeners

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

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

Dit is geen harde limiet. Met EventEmitter het exemplaar kunnen meer listeners worden toegevoegd, maar er wordt een traceringswaarschuwing naar stderr verzonden die aangeeft dat er een 'mogelijk EventEmitter-geheugenlek' is gedetecteerd. Voor één EventEmitter, kunnen de emitter.getMaxListeners() methoden 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 stacktracering voor dergelijke waarschuwingen weer te geven.

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

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

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

Methoden

close()
close(Callback<Disconnected>)

Hiermee wordt de transportverbinding gesloten en worden de clientresources vernietigd.

Opmerking: na het aanroepen van deze methode kan het clientobject niet opnieuw worden gebruikt.
fromAuthenticationProvider(AuthenticationProvider, any)

Hiermee maakt u een IoT Hub apparaatclient van de opgegeven verificatiemethode en gebruikt u het opgegeven transporttype.
fromConnectionString(string, any)

Hiermee maakt u een IoT Hub apparaatclient van de opgegeven verbindingsreeks met behulp van het opgegeven transporttype.
fromSharedAccessSignature(string, any)

Hiermee maakt u een IoT Hub apparaatclient van de opgegeven Shared Access Signature met behulp van het opgegeven transporttype.
getBlobSharedAccessSignature(string)
getBlobSharedAccessSignature(string, Callback<UploadParams>)

Het getBlobSharedAccessSignature SAS-token voor het gekoppelde opslagaccount wordt opgehaald uit IoT Hub
notifyBlobUploadStatus(string, boolean, number, string)
notifyBlobUploadStatus(string, boolean, number, string, ErrorCallback)

De notifyBlobUploadStatus methode verzendt IoT Hub het resultaat van een blob-upload.
onDeviceMethod(string, (request: DeviceMethodRequest, response: DeviceMethodResponse) => void)

Registreert een callback voor een methode met de naam methodName.
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)
uploadToBlob(string, Stream, number)
uploadToBlob(string, Stream, number, ErrorCallback)

Met de uploadToBlob methode wordt een stream geüpload naar een blob.

Overgenomen methoden

abandon(Message)
abandon(Message, Callback<MessageAbandoned>)
addAbortListener(AbortSignal, (event: Event) => void)

Luistert eenmaal naar de abort gebeurtenis op de opgegeven signal.

Luisteren naar de abort gebeurtenis bij afbrekingssignalen is onveilig en kan leiden tot resourcelekken omdat een andere derde partij met het signaal kan aanroepen e.stopImmediatePropagation(). Helaas kan Node.js dit niet wijzigen omdat dit in strijd is met de webstandaard. Bovendien kunt u met de oorspronkelijke API gemakkelijk vergeten listeners te verwijderen.

Met deze API kunt u veilig s gebruiken AbortSignalin Node.js API's door deze twee problemen op te lossen door naar de gebeurtenis te luisteren, stopImmediatePropagation zodat de listener niet kan worden uitgevoerd.

Retourneert een wegwerp, zodat deze gemakkelijker kan worden afgemeld.

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).
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<K>(string | symbol, AnyRest)

Synchroon roept alle 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 worden doorgegeven.

Retourneert true als de gebeurtenis listeners had, false anders.

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 met listeners voor de gebeurtenis met de naam eventName.

Voor EventEmitters gedraagt dit zich precies hetzelfde als het aanroepen .listeners op de emitter.

Voor EventTargets is dit de enige manier om de gebeurtenislisteners voor het gebeurtenisdoel 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 is ingesteld op defaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Retourneert de momenteel ingestelde maximale hoeveelheid listeners.

Voor EventEmitters gedraagt dit zich precies hetzelfde als het aanroepen .getMaxListeners op de emitter.

Voor EventTargets is dit de enige manier om het maximum aantal gebeurtenislisteners voor het gebeurtenisdoel te verkrijgen. Als het aantal gebeurtenis-handlers op één EventTarget de maximale set overschrijdt, wordt door EventTarget 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
}
getTwin()
getTwin(Callback<Twin>)
listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Een klassemethode die het aantal listeners retourneert voor de opgegeven eventName die is 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 met 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, StaticEventEmitterOptions) 
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 gebeurtenissen herhaalt eventName . Het genereert als de EventEmitter verzendt 'error'. Alle listeners worden verwijderd wanneer de lus wordt afgesloten. De value geretourneerd door elke iteratie is een matrix die bestaat uit de verzonden gebeurtenisargumenten.

Een AbortSignal kan worden gebruikt om het 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());
on<K>(string | symbol, (args: any[]) => void)

Hiermee voegt u de listener functie toe aan het einde van de listeners-matrix voor de gebeurtenis met de naam eventName. Er wordt niet gecontroleerd of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName en listener doorgeven, 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 emitter.prependListener() methode kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listeners-matrix.

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 opgegeven gebeurtenis verzendt of die wordt geweigerd als de verzendt 'error' tijdens het EventEmitter wachten. De Promise wordt omgezet met een matrix van alle argumenten die naar de opgegeven gebeurtenis zijn verzonden.

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

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 afhandeling 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 gebeurteniserror' zelf, wordt deze behandeld als elk 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)

Voegt een eenmaligelistener functie toe voor de gebeurtenis met de naam eventName. De volgende keer eventName dat deze listener wordt geactiveerd, wordt deze 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 emitter.prependOnceListener() methode kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listeners-matrix.

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
open()
open(Callback<Connected>)
prependListener<K>(string | symbol, (args: any[]) => void)

Hiermee voegt u de listener functie toe aan het begin van de listeners-matrix voor de gebeurtenis met de naam eventName. Er wordt niet gecontroleerd of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName en listener doorgeven, 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 eenmalige listener functie toe voor de gebeurtenis met de naam eventName aan het begin van de listeners-matrix. De volgende keer eventName dat deze listener wordt geactiveerd, wordt deze 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 met 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');
reject(Message)
reject(Message, Callback<MessageRejected>)
removeAllListeners(string | symbol)

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

Het is een slechte gewoonte om listeners te verwijderen die elders 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 één listener meerdere keren is toegevoegd aan de listenermatrix voor de opgegeven eventName, removeListener() moet meerdere keren worden aangeroepen om elk exemplaar te verwijderen.

Zodra een gebeurtenis wordt verzonden, worden alle listeners die eraan zijn gekoppeld op het moment van verzenden in de volgorde aangeroepen. Dit betekent dat aanroepen removeListener() of removeAllListeners() aanroepen na het verzenden en voordat de uitvoering van de laatste listener is voltooid, niet worden verwijderd uitemit() de actieve uitvoering. 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, verandert het aanroepen hiervan de positieindexen van elke listener die is geregistreerd nadat de listener is verwijderd. Dit heeft geen invloed op de volgorde waarin listeners worden aangeroepen, maar het betekent dat kopieën van de listenermatrix die door de emitter.listeners() methode worden geretourneerd, opnieuw moeten worden gemaakt.

Wanneer één functie meerdere keren als handler is toegevoegd voor één gebeurtenis (zoals in het onderstaande voorbeeld), removeListener() wordt het meest recent toegevoegde exemplaar verwijderd. In het voorbeeld is 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.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

EventEmitterStandaard wordt met s een waarschuwing afgedrukt als er meer dan 10 listeners zijn toegevoegd voor een bepaalde gebeurtenis. Dit is een handige standaard die helpt bij het vinden van geheugenlekken. Met emitter.setMaxListeners() de methode kan de limiet worden gewijzigd voor dit specifieke EventEmitter exemplaar. 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);
setRetryPolicy(RetryPolicy)

Hiermee stelt u het beleid voor opnieuw proberen dat door de client wordt gebruikt voor alle bewerkingen. De standaardwaarde is ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Constructordetails

Client(DeviceTransport, string, BlobUploadClient, FileUploadInterface) 

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

Parameters

transport
DeviceTransport

Een object dat de interface implementeert die van een transportobject wordt verwacht, bijvoorbeeld Http.

connStr

string

Een verbindingsreeks (optioneel: indien niet opgegeven, moet updateSharedAccessSignature worden aangeroepen om het SharedAccessSignature-token rechtstreeks in te stellen).

blobUploadClient

BlobUploadClient

Een object dat een stroom kan uploaden naar een blob.

fileUploadApi

FileUploadInterface

Een object dat wordt gebruikt voor de communicatie met IoT Hub voor aan Blob Storage gerelateerde acties.

Details van overgenomen eigenschap

captureRejections

Waarde: booleaanse waarde

Wijzig de standaardoptie captureRejections voor alle nieuwe EventEmitter objecten.

static captureRejections: boolean

Waarde van eigenschap

boolean

Overgenomen van InternalClient.captureRejections

captureRejectionSymbol

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

Meer informatie over het schrijven van een aangepaste rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Waarde van eigenschap

typeof captureRejectionSymbol

Overgenomen van InternalClient.captureRejectionSymbol

defaultMaxListeners

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

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

Dit is geen harde limiet. Met EventEmitter het exemplaar kunnen meer listeners worden toegevoegd, maar er wordt een traceringswaarschuwing naar stderr verzonden die aangeeft dat er een 'mogelijk EventEmitter-geheugenlek' is gedetecteerd. Voor één EventEmitter, kunnen de emitter.getMaxListeners() methoden 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 stacktracering voor dergelijke waarschuwingen weer te geven.

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

static defaultMaxListeners: number

Waarde van eigenschap

number

Overgenomen van InternalClient.defaultMaxListeners

errorMonitor

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

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

static errorMonitor: typeof errorMonitor

Waarde van eigenschap

typeof errorMonitor

Overgenomen van InternalClient.errorMonitor

Methodedetails

close() 

function close(): Promise<Disconnected>

Retouren

Promise<Disconnected>

close(Callback<Disconnected>)

Hiermee wordt de transportverbinding gesloten en worden de clientresources vernietigd.

Opmerking: na het aanroepen van deze methode kan het clientobject niet opnieuw worden gebruikt.

function close(closeCallback?: Callback<Disconnected>)

Parameters

closeCallback

Callback<Disconnected>

Optionele functie om aan te roepen zodra de verbinding met het transport is verbroken en de client is gesloten.

fromAuthenticationProvider(AuthenticationProvider, any)

Hiermee maakt u een IoT Hub apparaatclient van de opgegeven verificatiemethode en gebruikt u het opgegeven transporttype.

static function fromAuthenticationProvider(authenticationProvider: AuthenticationProvider, transportCtor: any): Client

Parameters

authenticationProvider

AuthenticationProvider

Object dat wordt gebruikt om de verificatieparameters voor de IoT-hub op te halen.

transportCtor

any

Het transportprotocol dat wordt gebruikt om verbinding te maken met IoT Hub.

Retouren

Client

fromConnectionString(string, any)

Hiermee maakt u een IoT Hub apparaatclient van de opgegeven verbindingsreeks met behulp van het opgegeven transporttype.

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

Parameters

connStr

string

Een verbindingsreeks die machtigingen voor 'apparaatverbinding' bevat voor een IoT-hub.

transportCtor

any

Een transportconstructor.

Retouren

Client

fromSharedAccessSignature(string, any)

Hiermee maakt u een IoT Hub apparaatclient van de opgegeven Shared Access Signature met behulp van het opgegeven transporttype.

static function fromSharedAccessSignature(sharedAccessSignature: string, transportCtor: any): Client

Parameters

sharedAccessSignature

string

Een shared access signature die machtigingen voor 'apparaatverbinding' bevat voor een IoT-hub.

transportCtor

any

Retouren

Client

getBlobSharedAccessSignature(string) 

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

Parameters

blobName

string

Retouren

Promise<UploadParams>

getBlobSharedAccessSignature(string, Callback<UploadParams>)

Het getBlobSharedAccessSignature SAS-token voor het gekoppelde opslagaccount wordt opgehaald uit IoT Hub

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

Parameters

blobName

string

De naam die moet worden gebruikt voor de blob die wordt gemaakt met de inhoud van de stream.

callback

Callback<UploadParams>

Optionele callback om aan te roepen wanneer het uploaden is voltooid.

notifyBlobUploadStatus(string, boolean, number, string) 

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

Parameters

correlationId

string

isSuccess

boolean

statusCode

number

statusDescription

string

Retouren

Promise<void>

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

De notifyBlobUploadStatus methode verzendt IoT Hub het resultaat van een blob-upload.

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

Parameters

correlationId

string

Een id voor het correleren van een uploadstatus met een specifieke blob. Gegenereerd tijdens de aanroep van getBlobSharedAccessSignature.

isSuccess

boolean

De geslaagde of mislukte status van het resultaat van de opslagblobbewerking.

statusCode

number

De HTTP-statuscode die is gekoppeld aan het resultaat van de opslagblob.

statusDescription

string

De beschrijving van de HTTP-statuscode.

callback

ErrorCallback

Optionele callback om aan te roepen wanneer het uploaden is voltooid.

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

Registreert een callback voor een methode met de naam methodName.

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

Parameters

methodName

string

Naam van de methode die wordt verwerkt door de callback

callback

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

Functie die moet worden aangeroepen wanneer een methodeaanvraag voor de aangeroepen methodName methode wordt ontvangen.

setOptions(DeviceClientOptions) 

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

Parameters

options
DeviceClientOptions

Retouren

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>) 

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

Parameters

options
DeviceClientOptions
done

Callback<TransportConfigured>

uploadToBlob(string, Stream, number) 

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

Parameters

blobName

string

stream

Stream

streamLength

number

Retouren

Promise<void>

uploadToBlob(string, Stream, number, ErrorCallback)

Met de uploadToBlob methode wordt een stream geüpload naar een blob.

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

Parameters

blobName

string

De naam die moet worden gebruikt voor de blob die wordt gemaakt met de inhoud van de stream.

stream

Stream

De gegevens naar die moeten worden geüpload naar de blob.

streamLength

number

De grootte van de gegevens die naar de blob moeten worden geüpload.

callback

ErrorCallback

Details overgenomen methode

abandon(Message) 

function abandon(message: Message): Promise<MessageAbandoned>

Parameters

message
Message

Retouren

Promise<MessageAbandoned>

Overgenomen van InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>) 

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

Parameters

message
Message
abandonCallback

Callback<MessageAbandoned>

Overgenomen van InternalClient.abandon

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

Luistert eenmaal naar de abort gebeurtenis op de opgegeven signal.

Luisteren naar de abort gebeurtenis bij afbrekingssignalen is onveilig en kan leiden tot resourcelekken omdat een andere derde partij met het signaal kan aanroepen e.stopImmediatePropagation(). Helaas kan Node.js dit niet wijzigen omdat dit in strijd is met de webstandaard. Bovendien kunt u met de oorspronkelijke API gemakkelijk vergeten listeners te verwijderen.

Met deze API kunt u veilig s gebruiken AbortSignalin Node.js API's door deze twee problemen op te lossen door naar de gebeurtenis te luisteren, stopImmediatePropagation zodat de listener niet kan worden uitgevoerd.

Retourneert een wegwerp, zodat deze gemakkelijker kan worden afgemeld.

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 InternalClient.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 InternalClient.addListener

complete(Message) 

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

Parameters

message
Message

Retouren

Promise<MessageCompleted>

Overgenomen van InternalClient.complete

complete(Message, Callback<MessageCompleted>) 

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

Parameters

message
Message
completeCallback

Callback<MessageCompleted>

Overgenomen van InternalClient.complete

emit<K>(string | symbol, AnyRest)

Synchroon roept alle 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 worden doorgegeven.

Retourneert true als de gebeurtenis listeners had, false anders.

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

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

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

Voor EventEmitters gedraagt dit zich precies hetzelfde als het aanroepen .listeners op de emitter.

Voor EventTargets is dit de enige manier om de gebeurtenislisteners voor het gebeurtenisdoel 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 InternalClient.getEventListeners

getMaxListeners()

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

function getMaxListeners(): number

Retouren

number

Overgenomen van InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Retourneert de momenteel ingestelde maximale hoeveelheid listeners.

Voor EventEmitters gedraagt dit zich precies hetzelfde als het aanroepen .getMaxListeners op de emitter.

Voor EventTargets is dit de enige manier om het maximum aantal gebeurtenislisteners voor het gebeurtenisdoel te verkrijgen. Als het aantal gebeurtenis-handlers op één EventTarget de maximale set overschrijdt, wordt door EventTarget 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 InternalClient.getMaxListeners

getTwin() 

function getTwin(): Promise<Twin>

Retouren

Promise<Twin>

Overgenomen van InternalClient.getTwin

getTwin(Callback<Twin>) 

function getTwin(done: Callback<Twin>)

Parameters

done

Callback<Twin>

Overgenomen van InternalClient.getTwin

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 die is 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 op uit te voeren

eventName

string | symbol

De naam van de gebeurtenis

Retouren

number

Overgenomen van InternalClient.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 waar naar wordt geluisterd

listener

Function

De functie gebeurtenis-handler

Retouren

number

Overgenomen van InternalClient.listenerCount

listeners<K>(string | symbol)

Retourneert een kopie van de matrix met 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 InternalClient.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 InternalClient.off

on(EventEmitter<DefaultEventMap>, string, StaticEventEmitterOptions) 

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 gebeurtenissen herhaalt eventName . Het genereert als de EventEmitter verzendt 'error'. Alle listeners worden verwijderd wanneer de lus wordt afgesloten. De value geretourneerd door elke iteratie is een matrix die bestaat uit de verzonden gebeurtenisargumenten.

Een AbortSignal kan worden gebruikt om het 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());

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string, options?: StaticEventEmitterOptions): AsyncIterableIterator<any>

Parameters

emitter

EventEmitter<DefaultEventMap>

eventName

string

De naam van de gebeurtenis waar naar wordt geluisterd

options

StaticEventEmitterOptions

Retouren

AsyncIterableIterator<any>

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

Overgenomen van InternalClient.on

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

Hiermee voegt u de listener functie toe aan het einde van de listeners-matrix voor de gebeurtenis met de naam eventName. Er wordt niet gecontroleerd of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName en listener doorgeven, 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 emitter.prependListener() methode kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listeners-matrix.

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 InternalClient.on

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

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

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

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 afhandeling 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 gebeurteniserror' zelf, wordt deze behandeld als elk 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 InternalClient.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 InternalClient.once

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

Voegt een eenmaligelistener functie toe voor de gebeurtenis met de naam eventName. De volgende keer eventName dat deze listener wordt geactiveerd, wordt deze 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 emitter.prependOnceListener() methode kan worden gebruikt als alternatief om de gebeurtenislistener toe te voegen aan het begin van de listeners-matrix.

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 InternalClient.once

open() 

function open(): Promise<Connected>

Retouren

Promise<Connected>

Overgenomen van InternalClient.open

open(Callback<Connected>) 

function open(openCallback: Callback<Connected>)

Parameters

openCallback

Callback<Connected>

Overgenomen van InternalClient.open

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

Hiermee voegt u de listener functie toe aan het begin van de listeners-matrix voor de gebeurtenis met de naam eventName. Er wordt niet gecontroleerd of de listener al is toegevoegd. Meerdere aanroepen die dezelfde combinatie van eventName en listener doorgeven, 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 InternalClient.prependListener

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

Hiermee voegt u een eenmalige listener functie toe voor de gebeurtenis met de naam eventName aan het begin van de listeners-matrix. De volgende keer eventName dat deze listener wordt geactiveerd, wordt deze 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 InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Retourneert een kopie van de matrix met 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 InternalClient.rawListeners

reject(Message) 

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

Parameters

message
Message

Retouren

Promise<MessageRejected>

Overgenomen van InternalClient.reject

reject(Message, Callback<MessageRejected>) 

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

Parameters

message
Message
rejectCallback

Callback<MessageRejected>

Overgenomen van InternalClient.reject

removeAllListeners(string | symbol)

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

Het is een slechte gewoonte om listeners te verwijderen die elders 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 InternalClient.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 één listener meerdere keren is toegevoegd aan de listenermatrix voor de opgegeven eventName, removeListener() moet meerdere keren worden aangeroepen om elk exemplaar te verwijderen.

Zodra een gebeurtenis wordt verzonden, worden alle listeners die eraan zijn gekoppeld op het moment van verzenden in de volgorde aangeroepen. Dit betekent dat aanroepen removeListener() of removeAllListeners() aanroepen na het verzenden en voordat de uitvoering van de laatste listener is voltooid, niet worden verwijderd uitemit() de actieve uitvoering. 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, verandert het aanroepen hiervan de positieindexen van elke listener die is geregistreerd nadat de listener is verwijderd. Dit heeft geen invloed op de volgorde waarin listeners worden aangeroepen, maar het betekent dat kopieën van de listenermatrix die door de emitter.listeners() methode worden geretourneerd, opnieuw moeten worden gemaakt.

Wanneer één functie meerdere keren als handler is toegevoegd voor één gebeurtenis (zoals in het onderstaande voorbeeld), removeListener() wordt het meest recent toegevoegde exemplaar verwijderd. In het voorbeeld is 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 InternalClient.removeListener

sendEvent(Message) 

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

Parameters

message
Message

Retouren

Promise<MessageEnqueued>

Overgenomen van InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>) 

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

Parameters

message
Message
sendEventCallback

Callback<MessageEnqueued>

Overgenomen van InternalClient.sendEvent

sendEventBatch(Message[]) 

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

Parameters

messages

Message[]

Retouren

Promise<MessageEnqueued>

Overgenomen van InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>) 

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

Parameters

messages

Message[]

sendEventBatchCallback

Callback<MessageEnqueued>

Overgenomen van InternalClient.sendEventBatch

setMaxListeners(number)

EventEmitterStandaard wordt met s een waarschuwing afgedrukt als er meer dan 10 listeners zijn toegevoegd voor een bepaalde gebeurtenis. Dit is een handige standaard die helpt bij het vinden van geheugenlekken. Met emitter.setMaxListeners() de methode kan de limiet worden gewijzigd voor dit specifieke EventEmitter exemplaar. 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 InternalClient.setMaxListeners

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

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

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

setMaxListeners(5, target, emitter);

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

Parameters

n

number

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

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

Overgenomen van InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

Hiermee stelt u het beleid voor opnieuw proberen dat door de client wordt gebruikt voor alle bewerkingen. De standaardwaarde is ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Parameters

policy

RetryPolicy

{RetryPolicy} Het beleid voor opnieuw proberen dat moet worden gebruikt voor alle toekomstige bewerkingen.

Overgenomen van InternalClient.setRetryPolicy

setTransportOptions(any) 

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

Parameters

options

any

Retouren

Promise<TransportConfigured>

Overgenomen van InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>) 

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

Parameters

options

any

done

Callback<TransportConfigured>

Overgenomen van InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>) 

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

Parameters

sharedAccessSignature

string

updateSasCallback

Callback<SharedAccessSignatureUpdated>

Overgenomen van InternalClient.updateSharedAccessSignature

[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 InternalClient.__@captureRejectionSymbol@138