Megosztás a következőn keresztül:

ModuleClient class

  • Referencia
Csomag:
azure-iot-device

IoT Hub-eszközügyfél, amellyel egy eszközt csatlakoztathat egy Azure IoT Hubhoz.

Az SDK felhasználóinak meg kell hívniuk az egyik gyári metódust, aConnectionString vagy a fromSharedAccessSignature egy IoT Hub-eszközügyfél létrehozásához.

Extends

InternalClient

Örökölt tulajdonságok

captureRejections

Érték: logikai

Módosítsa az alapértelmezett captureRejections beállítást az összes új EventEmitter objektumon.
captureRejectionSymbol

Érték: Symbol.for('nodejs.rejection')

Egyéni rejection handlerírásának ismertetése.
defaultMaxListeners

Alapértelmezés szerint legfeljebb 10 figyelő regisztrálható egyetlen eseményre. Ez a korlát a EventEmitter metódussal módosítható az egyes emitter.setMaxListeners(n) példányok esetében. Az összes példány alapértelmezett értékének módosításához a tulajdonság használható. Ha ez az érték nem pozitív szám, egy RangeError dob.

A events.defaultMaxListeners beállításakor körültekintően járjon el, mert a módosítás mindenEventEmitter példányt érint, beleértve a módosítás előtt létrehozott példányokat is. A emitter.setMaxListeners(n) hívása azonban továbbra is elsőbbséget élvez events.defaultMaxListeners.

Ez nem egy kemény korlát. A EventEmitter példány további figyelők hozzáadását teszi lehetővé, de nyomkövetési figyelmeztetést küld a stderrnek, amely azt jelzi, hogy "lehetséges EventEmitter memóriaszivárgás" észlelhető. Egyetlen EventEmitteresetén a emitter.getMaxListeners() és emitter.setMaxListeners() metódusokkal ideiglenesen elkerülheti a figyelmeztetést:

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

A --trace-warnings parancssori jelzővel megjeleníthető az ilyen figyelmeztetések veremkövetése.

A kibocsátott figyelmeztetés process.on('warning') vizsgálható, és további emitter, typeés count tulajdonságokkal rendelkezik, hivatkozva az eseményemitter-példányra, az esemény nevére és a csatlakoztatott figyelők számára. A name tulajdonsága 'MaxListenersExceededWarning'értékre van állítva.
errorMonitor

Ez a szimbólum csak 'error' események figyelésére szolgáló figyelő telepítésére használható. Az ezzel a szimbólummal telepített figyelőket a rendszer a normál 'error' figyelők hívása előtt hívja meg.

Ha figyelőt telepít ezzel a szimbólummal, az nem változtatja meg a viselkedést, ha 'error' eseményt bocsát ki. Ezért a folyamat akkor is összeomlik, ha nincs telepítve normál 'error' figyelő.

Metódusok

close()
close(Callback<Disconnected>)

Bezárja az átviteli kapcsolatot, és megsemmisíti az ügyfélerőforrásokat.

megjegyzés: A metódus meghívása után a ModuleClient objektum nem használható újra.
fromAuthenticationProvider(AuthenticationProvider, any)

Létrehoz egy IoT Hub-modulügyfélt a megadott hitelesítési módszerből és a megadott átviteli típus használatával.
fromConnectionString(string, any)

Létrehoz egy IoT Hub-eszközügyfélt az adott kapcsolati sztringből a megadott átviteli típus használatával.
fromEnvironment(any)
fromEnvironment(any, Callback<ModuleClient>)

Létrehoz egy IoT Hub-modulügyfélt a környezet konfigurációs adatainak használatával.

Ha létezik egy EdgeHubConnectionString vagy IotHubConnectionString nevű környezeti változó, akkor a rendszer ezt az értéket használja, és a viselkedés megegyezik a fromConnectionString átengedésével. Ha ezek a környezeti változók nem léteznek, akkor a következő változókat kell definiálni:

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"
fromSharedAccessSignature(string, any)

Létrehoz egy IoT Hub-modulügyfélt a megadott közös hozzáférésű jogosultságkódból az adott átviteli típus használatával.
invokeMethod(string, MethodParams)
invokeMethod(string, MethodParams, Callback<MethodResult>)

Metódust hív meg egy alsóbb rétegbeli eszközön vagy egy másik modulon ugyanazon az IoTEdge-eszközön. Vegye figyelembe, hogy ez a funkció csak akkor működik, ha a modul egy IoTEdge-eszköz részeként fut.
invokeMethod(string, string, MethodParams)
invokeMethod(string, string, MethodParams, Callback<MethodResult>)
onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Egy methodNamenevű metódus visszahívását regisztrálja.
sendOutputEvent(string, Message)
sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Esemény küldése az adott modul kimenetére
sendOutputEventBatch(string, Message[])
sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Eseménytömb küldése az adott modul kimenetére
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Átadja a beállításokat az átvitel konfigurálásához használható ModuleClient objektumnak.

Örökölt metódusok

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

Egyszer meghallgatja a megadott abortsignal eseményt.

A megszakított jelek abort eseményének hallgatása nem biztonságos, és erőforrás-szivárgáshoz vezethet, mivel a jellel rendelkező másik harmadik fél meghívhatja e.stopImmediatePropagation(). Sajnos Node.js nem módosíthatja ezt, mivel ez sérti a webes szabványt. Emellett az eredeti API megkönnyíti a figyelők eltávolítását.

Ez az API lehetővé teszi a AbortSignalNode.js API-kban való biztonságos használatát azáltal, hogy ezt a két problémát úgy oldja meg, hogy meghallgatja az eseményt, így stopImmediatePropagation nem akadályozza meg a figyelő futását.

Eldobható értéket ad vissza, hogy könnyebben leiratkozhassunk róla.

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 a következőhöz emitter.on(eventName, listener): .
complete(Message)
complete(Message, Callback<MessageCompleted>)
emit<K>(string | symbol, AnyRest)

Szinkron módon meghívja a eventNamenevű eseményre regisztrált összes figyelőt, a regisztráció sorrendjében, és átadja a megadott argumentumokat mindegyiknek.

true ad vissza, ha az esemény figyelői voltak, false ellenkező esetben.

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

Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket. A tömb értékei sztringek vagy 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)

A eventNamenevű esemény figyelőinek tömbjének másolatát adja vissza.

Az EventEmitteresetében ez pontosan ugyanúgy viselkedik, mint a .listeners hívása a kibocsátón.

Az EventTargetesetében ez az egyetlen módja annak, hogy az eseményfigyelők megkapják az eseménycélt. Ez hibakeresési és diagnosztikai célokra hasznos.

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

A EventEmitter aktuális maximális figyelőértékét adja vissza, amelyet emitter.setMaxListeners(n) vagy alapértelmezés szerint alapértelmezettMaxListenersértékre állít be.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

A jelenleg beállított maximális figyelőmennyiséget adja vissza.

Az EventEmitteresetében ez pontosan ugyanúgy viselkedik, mint a .getMaxListeners hívása a kibocsátón.

Az EventTargetesetében ez az egyetlen módja annak, hogy az eseménycélhoz tartozó maximális eseményfigyelőket lekérje. Ha egy EventTarget eseménykezelőinek száma meghaladja a maximális készletet, az EventTarget figyelmeztetést fog nyomtatni.

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)

Osztálymetódus, amely az adott eventName figyelőinek számát adja vissza az adott emitterregisztrálva.

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)

A eventNamenevű eseményt figyelő figyelők számát adja vissza. Ha listener van megadva, az visszaadja, hogy hányszor található a figyelő az esemény figyelőinek listájában.
listeners<K>(string | symbol)

A eventNamenevű esemény figyelőinek tömbjének másolatát adja vissza.

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 a következőhöz 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

Olyan AsyncIterator ad vissza, amely eventName eseményeket iterál. Akkor dob, ha a EventEmitter bocsát ki 'error'. Eltávolítja az összes figyelőt a ciklusból való kilépéskor. Az egyes iterációk által visszaadott value a kibocsátott eseményargumentumokból álló tömb.

Egy AbortSignal az eseményekre való várakozás megszakítására használható:

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

A close beállítással olyan eseménynevek tömbje adható meg, amelyek befejezik az iterációt:

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)

Hozzáadja a listener függvényt a eventNamenevű esemény figyelőtömbjének végéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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)

Létrehoz egy Promise, amely akkor teljesül, ha a EventEmitter az adott eseményt bocsátja ki, vagy ha a EventEmitter'error' bocsát ki várakozás közben. A Promise az adott eseménynek kibocsátott összes argumentum tömbjével oldja fel.

Ez a módszer szándékosan általános, és a webes platform EventTarget felülettel működik, amely nem rendelkezik speciális'error' eseményszemantikáival, és nem figyeli a 'error' eseményt.

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

A 'error' esemény speciális kezelése csak akkor használatos, ha events.once() egy másik eseményre való várakozásra szolgál. Ha events.once() a 'error' eseményre való várakozáshoz használják, akkor a rendszer bármilyen más típusú eseményként kezeli különleges kezelés nélkül:

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

Egy AbortSignal az eseményre való várakozás megszakítására használható:

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)

Hozzáad egy egyszerilistener függvényt a eventNamenevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependOnceListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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)

Hozzáadja a függvényt a nevű esemény figyelőtömbjének . Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Hozzáad egy egyszeri függvényt a figyelőtömb nevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
rawListeners<K>(string | symbol)

Visszaadja a eventNamenevű esemény figyelőinek tömbjének másolatát, beleértve a burkolókat is (például az .once()által létrehozottakat).

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)

Eltávolítja az összes figyelőt vagy a megadott eventName.

Helytelen gyakorlat eltávolítani a kód más részeiben hozzáadott figyelőket, különösen akkor, ha a EventEmitter-példányt más összetevő vagy modul hozta létre (például szoftvercsatornák vagy fájlstreamek).

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
removeListener<K>(string | symbol, (args: any[]) => void)

Eltávolítja a megadott listener a eventNamenevű esemény figyelőtömbéből.

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

removeListener() legfeljebb egy figyelőpéldányt távolít el a figyelőtömbből. Ha a megadott eventNameegyetlen figyelőt többször is hozzáadtak a figyelőtömbhöz, akkor az egyes példányok eltávolításához removeListener() többször kell meghívni.

Ha egy eseményt bocsát ki, a rendszer sorrendben meghívja a kibocsátáskor az ahhoz csatolt összes figyelőt. Ez azt jelenti, hogy a removeListener() vagy removeAllListeners() hívások kibocsátás és után, mielőtt az utolsó figyelő befejezi a végrehajtást, nem távolítja el őket a folyamatban lévőemit(). A későbbi események a várt módon viselkednek.

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

Mivel a figyelők kezelése belső tömb használatával történik, ennek meghívása megváltoztatja a figyelő eltávolítását követően regisztrált figyelők pozícióindexeit. Ez nem befolyásolja a figyelők meghívásának sorrendjét, de ez azt jelenti, hogy a figyelőtömbnek az emitter.listeners() metódus által visszaadott másolatait újra létre kell hozni.

Ha egyetlen függvényt többször adtak hozzá kezelőként egyetlen eseményhez (az alábbi példához hasonlóan), removeListener() eltávolítja a legutóbb hozzáadott példányt. A példában a once('ping') figyelő el lesz távolítva:

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

Alapértelmezés szerint EventEmitters figyelmeztetést jelenít meg, ha egy adott eseményhez több mint 10 figyelő van hozzáadva. Ez egy hasznos alapértelmezett beállítás, amely segít megtalálni a memóriavesztést. A emitter.setMaxListeners() metódus lehetővé teszi a korlát módosítását ehhez az adott EventEmitter példányhoz. Az érték beállítható Infinity (vagy 0) értékre, hogy korlátlan számú figyelőt jelöljön.

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
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)

Beállítja az ügyfél által az összes művelethez használt újrapróbálkozási szabályzatot. Az alapértelmezett érték ExponentialBackoffWithJitter.
setTransportOptions(any)
setTransportOptions(any, Callback<TransportConfigured>)
updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>)
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Örökölt tulajdonság részletei

captureRejections

Érték: logikai

Módosítsa az alapértelmezett captureRejections beállítást az összes új EventEmitter objektumon.

static captureRejections: boolean

Tulajdonság értéke

boolean

InternalClient.captureRejections örökölte

captureRejectionSymbol

Érték: Symbol.for('nodejs.rejection')

Egyéni rejection handlerírásának ismertetése.

static captureRejectionSymbol: typeof captureRejectionSymbol

Tulajdonság értéke

typeof captureRejectionSymbol

InternalClient.captureRejectionSymbol örökölte

defaultMaxListeners

Alapértelmezés szerint legfeljebb 10 figyelő regisztrálható egyetlen eseményre. Ez a korlát a EventEmitter metódussal módosítható az egyes emitter.setMaxListeners(n) példányok esetében. Az összes példány alapértelmezett értékének módosításához a tulajdonság használható. Ha ez az érték nem pozitív szám, egy RangeError dob.

A events.defaultMaxListeners beállításakor körültekintően járjon el, mert a módosítás mindenEventEmitter példányt érint, beleértve a módosítás előtt létrehozott példányokat is. A emitter.setMaxListeners(n) hívása azonban továbbra is elsőbbséget élvez events.defaultMaxListeners.

Ez nem egy kemény korlát. A EventEmitter példány további figyelők hozzáadását teszi lehetővé, de nyomkövetési figyelmeztetést küld a stderrnek, amely azt jelzi, hogy "lehetséges EventEmitter memóriaszivárgás" észlelhető. Egyetlen EventEmitteresetén a emitter.getMaxListeners() és emitter.setMaxListeners() metódusokkal ideiglenesen elkerülheti a figyelmeztetést:

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

A --trace-warnings parancssori jelzővel megjeleníthető az ilyen figyelmeztetések veremkövetése.

A kibocsátott figyelmeztetés process.on('warning') vizsgálható, és további emitter, typeés count tulajdonságokkal rendelkezik, hivatkozva az eseményemitter-példányra, az esemény nevére és a csatlakoztatott figyelők számára. A name tulajdonsága 'MaxListenersExceededWarning'értékre van állítva.

static defaultMaxListeners: number

Tulajdonság értéke

number

InternalClient.defaultMaxListeners örökölte

errorMonitor

Ez a szimbólum csak 'error' események figyelésére szolgáló figyelő telepítésére használható. Az ezzel a szimbólummal telepített figyelőket a rendszer a normál 'error' figyelők hívása előtt hívja meg.

Ha figyelőt telepít ezzel a szimbólummal, az nem változtatja meg a viselkedést, ha 'error' eseményt bocsát ki. Ezért a folyamat akkor is összeomlik, ha nincs telepítve normál 'error' figyelő.

static errorMonitor: typeof errorMonitor

Tulajdonság értéke

typeof errorMonitor

InternalClient.errorMonitor örökölte

Metódus adatai

close() 

function close(): Promise<Disconnected>

Válaszok

Promise<Disconnected>

close(Callback<Disconnected>)

Bezárja az átviteli kapcsolatot, és megsemmisíti az ügyfélerőforrásokat.

megjegyzés: A metódus meghívása után a ModuleClient objektum nem használható újra.

function close(closeCallback?: Callback<Disconnected>)

Paraméterek

closeCallback

Callback<Disconnected>

Nem kötelező függvény, amely az átvitel leválasztása és az ügyfél bezárása után hívható meg.

fromAuthenticationProvider(AuthenticationProvider, any)

Létrehoz egy IoT Hub-modulügyfélt a megadott hitelesítési módszerből és a megadott átviteli típus használatával.

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

Paraméterek

authenticationProvider

AuthenticationProvider

Az IoT Hub hitelesítési paramétereinek lekéréséhez használt objektum.

transportCtor

any

Az IoT Hubhoz való csatlakozáshoz használt átviteli protokoll.

Válaszok

ModuleClient

fromConnectionString(string, any)

Létrehoz egy IoT Hub-eszközügyfélt az adott kapcsolati sztringből a megadott átviteli típus használatával.

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

Paraméterek

connStr

string

Egy kapcsolati sztring, amely az "eszközcsatlakozás" engedélyeket foglalja magában egy IoT Hubon.

transportCtor

any

Egy szállítókonstruktor.

Válaszok

ModuleClient

fromEnvironment(any) 

static function fromEnvironment(transportCtor: any): Promise<ModuleClient>

Paraméterek

transportCtor

any

Válaszok

Promise<ModuleClient>

fromEnvironment(any, Callback<ModuleClient>)

Létrehoz egy IoT Hub-modulügyfélt a környezet konfigurációs adatainak használatával.

Ha létezik egy EdgeHubConnectionString vagy IotHubConnectionString nevű környezeti változó, akkor a rendszer ezt az értéket használja, és a viselkedés megegyezik a fromConnectionString átengedésével. Ha ezek a környezeti változók nem léteznek, akkor a következő változókat kell definiálni:

- IOTEDGE_WORKLOADURI          URI for iotedged's workload API
- IOTEDGE_DEVICEID             Device identifier
- IOTEDGE_MODULEID             Module identifier
- IOTEDGE_MODULEGENERATIONID   Module generation identifier
- IOTEDGE_IOTHUBHOSTNAME       IoT Hub host name
- IOTEDGE_AUTHSCHEME           Authentication scheme to use; must be "sasToken"

static function fromEnvironment(transportCtor: any, callback?: Callback<ModuleClient>)

Paraméterek

transportCtor

any

Az IoT Hubhoz való csatlakozáshoz használt átviteli protokoll.

callback

Callback<ModuleClient>

Nem kötelező visszahívás a ModuleClient létrehozásakor vagy hiba esetén az ügyfél létrehozásakor.

fromSharedAccessSignature(string, any)

Létrehoz egy IoT Hub-modulügyfélt a megadott közös hozzáférésű jogosultságkódból az adott átviteli típus használatával.

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

Paraméterek

sharedAccessSignature

string

Egy közös hozzáférésű jogosultságkód, amely az "eszközcsatlakozás" engedélyeket foglalja magában egy IoT Hubon.

transportCtor

any

Válaszok

ModuleClient

invokeMethod(string, MethodParams) 

function invokeMethod(deviceId: string, methodParams: MethodParams): Promise<MethodResult>

Paraméterek

deviceId

string

methodParams

MethodParams

Válaszok

Promise<MethodResult>

invokeMethod(string, MethodParams, Callback<MethodResult>)

Metódust hív meg egy alsóbb rétegbeli eszközön vagy egy másik modulon ugyanazon az IoTEdge-eszközön. Vegye figyelembe, hogy ez a funkció csak akkor működik, ha a modul egy IoTEdge-eszköz részeként fut.

function invokeMethod(deviceId: string, methodParams: MethodParams, callback?: Callback<MethodResult>)

Paraméterek

deviceId

string

céleszköz azonosítója

methodParams

MethodParams

a közvetlen metódushívás paraméterei

callback

Callback<MethodResult>

nem kötelező visszahívás, amely hibaobjektummal vagy a metódushívás eredményével lesz meghívva.

invokeMethod(string, string, MethodParams) 

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams): Promise<MethodResult>

Paraméterek

deviceId

string

moduleId

string

methodParams

MethodParams

Válaszok

Promise<MethodResult>

invokeMethod(string, string, MethodParams, Callback<MethodResult>) 

function invokeMethod(deviceId: string, moduleId: string, methodParams: MethodParams, callback: Callback<MethodResult>)

Paraméterek

deviceId

string

moduleId

string

methodParams

MethodParams

callback

Callback<MethodResult>

onMethod(string, DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Egy methodNamenevű metódus visszahívását regisztrálja.

function onMethod(methodName: string, callback: DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>)

Paraméterek

methodName

string

A visszahívás által kezelni kívánt metódus neve

callback

DoubleValueCallback<DeviceMethodRequest, DeviceMethodResponse>

A methodName nevű metódusra vonatkozó metóduskérések fogadásakor meghívandó függvény.

sendOutputEvent(string, Message) 

function sendOutputEvent(outputName: string, message: Message): Promise<MessageEnqueued>

Paraméterek

outputName

string

message
Message

Válaszok

Promise<MessageEnqueued>

sendOutputEvent(string, Message, Callback<MessageEnqueued>)

Esemény küldése az adott modul kimenetére

function sendOutputEvent(outputName: string, message: Message, callback?: Callback<MessageEnqueued>)

Paraméterek

outputName

string

Annak a kimenetnek a neve, amelybe az eseményt el szeretné küldeni

message
Message

A megadott kimenetre küldendő üzenet

callback

Callback<MessageEnqueued>

Nem kötelező függvény, amely meghívható a művelet várólistára helyezésekor.

sendOutputEventBatch(string, Message[]) 

function sendOutputEventBatch(outputName: string, messages: Message[]): Promise<MessageEnqueued>

Paraméterek

outputName

string

messages

Message[]

Válaszok

Promise<MessageEnqueued>

sendOutputEventBatch(string, Message[], Callback<MessageEnqueued>)

Eseménytömb küldése az adott modul kimenetére

function sendOutputEventBatch(outputName: string, messages: Message[], callback?: Callback<MessageEnqueued>)

Paraméterek

outputName

string

Annak a kimenetnek a neve, amelybe az eseményeket el szeretné küldeni

messages

Message[]

callback

Callback<MessageEnqueued>

A műveletek várólistára helyezésekor hívható függvény.

setOptions(DeviceClientOptions) 

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

Paraméterek

options
DeviceClientOptions

Válaszok

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Átadja a beállításokat az átvitel konfigurálásához használható ModuleClient objektumnak.

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

Paraméterek

options
DeviceClientOptions

DeviceClientOptions objektum.

done

Callback<TransportConfigured>

Nem kötelező visszahívás a beállítások megadása után a híváshoz.

Örökölt metódus részletei

abandon(Message) 

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

Paraméterek

message
Message

Válaszok

Promise<MessageAbandoned>

InternalClient.abandon örökölte

abandon(Message, Callback<MessageAbandoned>) 

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

Paraméterek

message
Message
abandonCallback

Callback<MessageAbandoned>

InternalClient.abandon örökölte

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

Egyszer meghallgatja a megadott abortsignal eseményt.

A megszakított jelek abort eseményének hallgatása nem biztonságos, és erőforrás-szivárgáshoz vezethet, mivel a jellel rendelkező másik harmadik fél meghívhatja e.stopImmediatePropagation(). Sajnos Node.js nem módosíthatja ezt, mivel ez sérti a webes szabványt. Emellett az eredeti API megkönnyíti a figyelők eltávolítását.

Ez az API lehetővé teszi a AbortSignalNode.js API-kban való biztonságos használatát azáltal, hogy ezt a két problémát úgy oldja meg, hogy meghallgatja az eseményt, így stopImmediatePropagation nem akadályozza meg a figyelő futását.

Eldobható értéket ad vissza, hogy könnyebben leiratkozhassunk róla.

import { addAbortListener } from 'node:events';

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

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

Paraméterek

signal

AbortSignal

resource

(event: Event) => void

Válaszok

Disposable

Eldobható, amely eltávolítja a abort figyelőt.

InternalClient.addAbortListener örökölte

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

Alias a következőhöz emitter.on(eventName, listener): .

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

ModuleClient

InternalClient.addListener örökölte

complete(Message) 

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

Paraméterek

message
Message

Válaszok

Promise<MessageCompleted>

InternalClient.complete örökölte

complete(Message, Callback<MessageCompleted>) 

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

Paraméterek

message
Message
completeCallback

Callback<MessageCompleted>

InternalClient.complete örökölte

emit<K>(string | symbol, AnyRest)

Szinkron módon meghívja a eventNamenevű eseményre regisztrált összes figyelőt, a regisztráció sorrendjében, és átadja a megadott argumentumokat mindegyiknek.

true ad vissza, ha az esemény figyelői voltak, false ellenkező esetben.

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

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

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

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

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

function emit<K>(eventName: string | symbol, args: AnyRest): boolean

Paraméterek

eventName

string | symbol

args

AnyRest

Válaszok

boolean

InternalClient.emit örökölte

eventNames()

Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket. A tömb értékei sztringek vagy 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)[]

Válaszok

(string | symbol)[]

InternalClient.eventNames örökölte

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

A eventNamenevű esemény figyelőinek tömbjének másolatát adja vissza.

Az EventEmitteresetében ez pontosan ugyanúgy viselkedik, mint a .listeners hívása a kibocsátón.

Az EventTargetesetében ez az egyetlen módja annak, hogy az eseményfigyelők megkapják az eseménycélt. Ez hibakeresési és diagnosztikai célokra hasznos.

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

Paraméterek

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

Válaszok

Function[]

InternalClient.getEventListeners örökölte

getMaxListeners()

A EventEmitter aktuális maximális figyelőértékét adja vissza, amelyet emitter.setMaxListeners(n) vagy alapértelmezés szerint alapértelmezettMaxListenersértékre állít be.

function getMaxListeners(): number

Válaszok

number

InternalClient.getMaxListeners örökölte

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

A jelenleg beállított maximális figyelőmennyiséget adja vissza.

Az EventEmitteresetében ez pontosan ugyanúgy viselkedik, mint a .getMaxListeners hívása a kibocsátón.

Az EventTargetesetében ez az egyetlen módja annak, hogy az eseménycélhoz tartozó maximális eseményfigyelőket lekérje. Ha egy EventTarget eseménykezelőinek száma meghaladja a maximális készletet, az EventTarget figyelmeztetést fog nyomtatni.

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

Paraméterek

emitter

EventEmitter<DefaultEventMap> | EventTarget

Válaszok

number

InternalClient.getMaxListeners örökölte

getTwin() 

function getTwin(): Promise<Twin>

Válaszok

Promise<Twin>

InternalClient.getTwin örökölte

getTwin(Callback<Twin>) 

function getTwin(done: Callback<Twin>)

Paraméterek

done

Callback<Twin>

InternalClient.getTwin örökölte

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Figyelmeztetés

Ez az API már elavult.

Since v3.2.0 - Use listenerCount instead.

Osztálymetódus, amely az adott eventName figyelőinek számát adja vissza az adott emitterregisztrálva.

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

Paraméterek

emitter

EventEmitter<DefaultEventMap>

A lekérdezendő emitter

eventName

string | symbol

Az esemény neve

Válaszok

number

InternalClient.listenerCount örökölte

listenerCount<K>(string | symbol, Function)

A eventNamenevű eseményt figyelő figyelők számát adja vissza. Ha listener van megadva, az visszaadja, hogy hányszor található a figyelő az esemény figyelőinek listájában.

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

Paraméterek

eventName

string | symbol

A figyelt esemény neve

listener

Function

Az eseménykezelő függvény

Válaszok

number

InternalClient.listenerCount örökölte

listeners<K>(string | symbol)

A eventNamenevű esemény figyelőinek tömbjének másolatát adja vissza.

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

function listeners<K>(eventName: string | symbol): Function[]

Paraméterek

eventName

string | symbol

Válaszok

Function[]

InternalClient.listeners örökölte

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

Alias a következőhöz emitter.removeListener(): .

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

ModuleClient

InternalClient.off örökölte

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

Olyan AsyncIterator ad vissza, amely eventName eseményeket iterál. Akkor dob, ha a EventEmitter bocsát ki 'error'. Eltávolítja az összes figyelőt a ciklusból való kilépéskor. Az egyes iterációk által visszaadott value a kibocsátott eseményargumentumokból álló tömb.

Egy AbortSignal az eseményekre való várakozás megszakítására használható:

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

A close beállítással olyan eseménynevek tömbje adható meg, amelyek befejezik az iterációt:

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>

Paraméterek

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

Válaszok

AsyncIterator<any[], any, any>

A AsyncIterator által kibocsátott eventName eseményeket iteráló emitter

InternalClient.on örökölte

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

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

Paraméterek

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

Válaszok

AsyncIterator<any[], any, any>

InternalClient.on örökölte

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

Hozzáadja a listener függvényt a eventNamenevű esemény figyelőtömbjének végéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

ModuleClient

InternalClient.on örökölte

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

Létrehoz egy Promise, amely akkor teljesül, ha a EventEmitter az adott eseményt bocsátja ki, vagy ha a EventEmitter'error' bocsát ki várakozás közben. A Promise az adott eseménynek kibocsátott összes argumentum tömbjével oldja fel.

Ez a módszer szándékosan általános, és a webes platform EventTarget felülettel működik, amely nem rendelkezik speciális'error' eseményszemantikáival, és nem figyeli a 'error' eseményt.

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

A 'error' esemény speciális kezelése csak akkor használatos, ha events.once() egy másik eseményre való várakozásra szolgál. Ha events.once() a 'error' eseményre való várakozáshoz használják, akkor a rendszer bármilyen más típusú eseményként kezeli különleges kezelés nélkül:

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

Egy AbortSignal az eseményre való várakozás megszakítására használható:

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

Paraméterek

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

Válaszok

Promise<any[]>

InternalClient.once örökölte

once(EventTarget, string, StaticEventEmitterOptions) 

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

Paraméterek

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

Válaszok

Promise<any[]>

InternalClient.once örökölte

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

Hozzáad egy egyszerilistener függvényt a eventNamenevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

Alapértelmezés szerint az eseményfigyelők a hozzáadásuk sorrendjében lesznek meghívva. A emitter.prependOnceListener() metódus alternatívaként használható az eseményfigyelő hozzáadásához a figyelőtömb elejéhez.

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

ModuleClient

InternalClient.once örökölte

open() 

function open(): Promise<Connected>

Válaszok

Promise<Connected>

InternalClient.open örökölte

open(Callback<Connected>) 

function open(openCallback: Callback<Connected>)

Paraméterek

openCallback

Callback<Connected>

InternalClient.open örökölte

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

Hozzáadja a függvényt a nevű esemény figyelőtömbjének . Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadták-e. A eventName és a listener azonos kombinációját átadó hívások több alkalommal is hozzáadják és meghívják a listener.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

ModuleClient

InternalClient.prependListener örökölte

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

Hozzáad egy egyszeri függvényt a figyelőtömb nevű eseményhez. A következő eventName aktiválásakor a figyelő el lesz távolítva, majd meghívódik.

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

ModuleClient

InternalClient.prependOnceListener örökölte

rawListeners<K>(string | symbol)

Visszaadja a eventNamenevű esemény figyelőinek tömbjének másolatát, beleértve a burkolókat is (például az .once()által létrehozottakat).

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

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

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

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

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

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

function rawListeners<K>(eventName: string | symbol): Function[]

Paraméterek

eventName

string | symbol

Válaszok

Function[]

InternalClient.rawListeners örökölte

reject(Message) 

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

Paraméterek

message
Message

Válaszok

Promise<MessageRejected>

InternalClient.reject örökölte

reject(Message, Callback<MessageRejected>) 

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

Paraméterek

message
Message
rejectCallback

Callback<MessageRejected>

InternalClient.reject örökölte

removeAllListeners(string | symbol)

Eltávolítja az összes figyelőt vagy a megadott eventName.

Helytelen gyakorlat eltávolítani a kód más részeiben hozzáadott figyelőket, különösen akkor, ha a EventEmitter-példányt más összetevő vagy modul hozta létre (például szoftvercsatornák vagy fájlstreamek).

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

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

Paraméterek

eventName

string | symbol

Válaszok

ModuleClient

InternalClient.removeAllListeners örökölte

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

Eltávolítja a megadott listener a eventNamenevű esemény figyelőtömbéből.

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

removeListener() legfeljebb egy figyelőpéldányt távolít el a figyelőtömbből. Ha a megadott eventNameegyetlen figyelőt többször is hozzáadtak a figyelőtömbhöz, akkor az egyes példányok eltávolításához removeListener() többször kell meghívni.

Ha egy eseményt bocsát ki, a rendszer sorrendben meghívja a kibocsátáskor az ahhoz csatolt összes figyelőt. Ez azt jelenti, hogy a removeListener() vagy removeAllListeners() hívások kibocsátás és után, mielőtt az utolsó figyelő befejezi a végrehajtást, nem távolítja el őket a folyamatban lévőemit(). A későbbi események a várt módon viselkednek.

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

Mivel a figyelők kezelése belső tömb használatával történik, ennek meghívása megváltoztatja a figyelő eltávolítását követően regisztrált figyelők pozícióindexeit. Ez nem befolyásolja a figyelők meghívásának sorrendjét, de ez azt jelenti, hogy a figyelőtömbnek az emitter.listeners() metódus által visszaadott másolatait újra létre kell hozni.

Ha egyetlen függvényt többször adtak hozzá kezelőként egyetlen eseményhez (az alábbi példához hasonlóan), removeListener() eltávolítja a legutóbb hozzáadott példányt. A példában a once('ping') figyelő el lesz távolítva:

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

ModuleClient

InternalClient.removeListener örökölte

sendEvent(Message) 

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

Paraméterek

message
Message

Válaszok

Promise<MessageEnqueued>

InternalClient.sendEvent örökölte

sendEvent(Message, Callback<MessageEnqueued>) 

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

Paraméterek

message
Message
sendEventCallback

Callback<MessageEnqueued>

InternalClient.sendEvent örökölte

sendEventBatch(Message[]) 

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

Paraméterek

messages

Message[]

Válaszok

Promise<MessageEnqueued>

InternalClient.sendEventBatch örökölte

sendEventBatch(Message[], Callback<MessageEnqueued>) 

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

Paraméterek

messages

Message[]

sendEventBatchCallback

Callback<MessageEnqueued>

InternalClient.sendEventBatch örökölte

setMaxListeners(number)

Alapértelmezés szerint EventEmitters figyelmeztetést jelenít meg, ha egy adott eseményhez több mint 10 figyelő van hozzáadva. Ez egy hasznos alapértelmezett beállítás, amely segít megtalálni a memóriavesztést. A emitter.setMaxListeners() metódus lehetővé teszi a korlát módosítását ehhez az adott EventEmitter példányhoz. Az érték beállítható Infinity (vagy 0) értékre, hogy korlátlan számú figyelőt jelöljön.

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.

function setMaxListeners(n: number): ModuleClient

Paraméterek

n

number

Válaszok

ModuleClient

InternalClient.setMaxListeners örökölte

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

Paraméterek

n

number

Nem negatív szám. A figyelők maximális száma EventTarget eseményenként.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

Nulla vagy több {EventTarget} vagy {EventEmitter} példány. Ha nincs megadva, a n az összes újonnan létrehozott {EventTarget} és {EventEmitter} objektum alapértelmezett maximális értékeként van beállítva.

InternalClient.setMaxListeners örökölte

setRetryPolicy(RetryPolicy)

Beállítja az ügyfél által az összes művelethez használt újrapróbálkozási szabályzatot. Az alapértelmezett érték ExponentialBackoffWithJitter.

function setRetryPolicy(policy: RetryPolicy)

Paraméterek

policy

RetryPolicy

{RetryPolicy} Az újrapróbálkozási szabályzat, amelyet minden jövőbeli művelethez használni kell.

InternalClient.setRetryPolicy örökölte

setTransportOptions(any) 

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

Paraméterek

options

any

Válaszok

Promise<TransportConfigured>

InternalClient.setTransportOptions örökölte

setTransportOptions(any, Callback<TransportConfigured>) 

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

Paraméterek

options

any

done

Callback<TransportConfigured>

InternalClient.setTransportOptions örökölte

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>) 

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

Paraméterek

sharedAccessSignature

string

updateSasCallback

Callback<SharedAccessSignatureUpdated>

InternalClient.updateSharedAccessSignature örökölte

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

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

Paraméterek

error

Error

event

string | symbol

args

AnyRest

örökölt InternalClient.__@captureRejectionSymbol@141