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 vagya FromSharedAccessSignature metódusból 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')

Megtudhatja, hogyan írhat egyénit rejection handler.
defaultMaxListeners

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

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

Ez nem egy kemény korlát. A EventEmitter példány több figyelő hozzáadását teszi lehetővé, de nyomkövetési figyelmeztetést küld az stderrnek, amely azt jelzi, hogy "lehetséges EventEmitter memóriavesztés" észlelhető. A és emitter.setMaxListeners() a emitter.getMaxListeners() metódusok használatával EventEmitterideiglenesen elkerülheti ezt 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ítheti az ilyen figyelmeztetések veremkövetését.

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

Ezt a szimbólumot csak figyelési 'error' események figyelőjének telepítéséhez kell használni. Az ezzel a szimbólummal telepített figyelők a normál 'error' figyelők hívása előtt lesznek meghívva.

Ha figyelőt telepít ezzel a szimbólummal, az nem változtatja meg a viselkedést az 'error' esemény kibocsátása után. Ezért a folyamat továbbra is összeomlik, ha nincs rendszeres 'error' figyelő telepítve.

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 karakterlánc 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 egy környezeti változó neve EdgeHubConnectionString vagy IotHubConnectionString létezik, akkor a rendszer ezt az értéket használja, és a viselkedése megegyezik a bemenő hívással fromConnectionString . 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 megosztott 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 nevű metódus methodNamevisszahí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ények tömbjének küldése az adott modul kimenetére
setOptions(DeviceClientOptions)
setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Az átvitel konfigurálásához használható beállításokat ModuleClient adja át az objektumnak.

Örökölt metódusok

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

Egyszer hallgatja meg az eseményt abort a megadott signalwebhelyen.

abort Az esemény megszakítási jeleken való hallgatása nem biztonságos, és erőforrás-szivárgáshoz vezethet, mivel egy másik, a jellel rendelkező harmadik fél meghívhatja a következőte.stopImmediatePropagation(): . Sajnos Node.js nem módosíthatja ezt, mivel ez sértené 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 az s biztonságos használatát AbortSignalNode.js API-kban, ha ezt a két problémát úgy oldja meg, hogy meghallgatja az eseményt, ami 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 nevű eventNameeseményhez regisztrált összes figyelőt a regisztráció sorrendjében, és átadja a megadott argumentumokat mindegyiknek.

Akkor ad true vissza, ha az eseménynek voltak figyelői, 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 a kibocsátó regisztrált figyelőket tartalmaz. 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 nevű esemény eventNamefigyelőinek tömbjének másolatát adja vissza.

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

Az s esetében EventTargetez az egyetlen módja annak, hogy lekérje az eseménycél eseményfigyelőit. 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()

Az aktuális maximális figyelőértéket adja vissza, EventEmitter amelynek emitter.setMaxListeners(n) alapértelmezett vagy alapértelmezett értéke a DefaultMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

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

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

Az s esetében EventTargetez az egyetlen módja annak, hogy lekérje az eseménycélhoz tartozó maximális eseményfigyelőket. 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 a megadott eventName regisztrált figyelők számát adja vissza az adott emitterrendszeren.

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 nevű eseményt eventNamefigyelő figyelők számát adja vissza. Ha listener meg van adva, visszaadja, hogy hányszor található a figyelő az esemény figyelőinek listájában.
listeners<K>(string | symbol)

A nevű esemény eventNamefigyelő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, 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

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

Az eseményekre AbortSignal való várakozás megszakításához 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());
on<K>(string | symbol, (args: any[]) => void)

Hozzáadja a listener függvényt a nevű esemény eventNamefigyelőtömbjének végéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadva van-e. Több hívás, amely ugyanazt a kombinációt eventName adja át, és listener ennek eredményeként a listener rendszer többször is hozzáadja és meghívja őket.

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

A parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhí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)

Olyan eseményt Promise hoz létre, amely akkor teljesül, ha az EventEmitter adott eseményt bocsátja ki, vagy ha a kibocsátja 'error' a EventEmitter várakozás közben. A Promise feloldás az adott eseménynek kibocsátott összes argumentum tömbjével oldható fel.

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

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

const ee = new EventEmitter();

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

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

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

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

Az esemény speciális kezelését 'error' csak akkor használja a rendszer, ha events.once() egy másik eseményre vár. Ha events.once() magát azerror' eseményt várja meg, akkor a rendszer bármilyen más típusú eseményként kezeli, különös 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

Az AbortSignal eseményre való várakozás megszakításához 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 nevű eventNameeseményhez. A következő aktiváláskor eventName a figyelő el lesz távolítva, majd meghívódik.

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

A parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhí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 listener függvényt a nevű esemény eventNamefigyelőtömbjének elejéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadva van-e. Több hívás, amely ugyanazt a kombinációt eventName adja át, és listener ennek eredményeként a listener rendszer többször is hozzáadja és meghívja őket.

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

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

Hozzáad egy egyszerilistener függvényt a nevesített eventName eseményhez a figyelőtömb elejéhez . A következő aktiváláskor eventName a figyelő el lesz távolítva, majd meghívódik.

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

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

Visszaadja az esemény eventNamefigyelőinek tömbjének másolatát, beleértve a burkolókat is (például a által .once()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 eventNamefigyelőt.

Helytelen gyakorlat eltávolítani a kód más részeihez 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 parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhívások láncoltak legyenek.
removeListener<K>(string | symbol, (args: any[]) => void)

Eltávolítja a megadott listener értéket a nevű eventNameesemé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 egy figyelőt többször is hozzáadtak a megadott eventNamefigyelőtömbhöz, akkor removeListener() az egyes példányok eltávolításához többször kell meghívni őket.

Az esemény kibocsátása után a rendszer sorrendben meghívja az ahhoz a kibocsátáskor csatolt összes figyelőt. Ez azt jelenti, hogy a removeListener() kibocsátás után és removeAllListeners() az utolsó figyelő végrehajtása előtt a hívások nem távolítják el őket a folyamatban lévőbőlemit(). 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, ez a hívás megváltoztatja a figyelő eltávolítása után regisztrált figyelők pozícióindexeit. Ez nem befolyásolja a figyelők hívásának sorrendjét, de ez azt jelenti, hogy a metódus által emitter.listeners() visszaadott figyelőtömb minden példányát ú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() a rendszer 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 parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhívások láncoltak legyenek.
sendEvent(Message)
sendEvent(Message, Callback<MessageEnqueued>)
sendEventBatch(Message[])
sendEventBatch(Message[], Callback<MessageEnqueued>)
setMaxListeners(number)

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

A parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhí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űveleten használt újrapróbálkozási szabályzatot. Az alapértelmezett érték az ExponenciálisBackoffWithJitter.
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

Örökölt forrás InternalClient.captureRejections

captureRejectionSymbol

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

Megtudhatja, hogyan írhat egyénit rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Tulajdonság értéke

typeof captureRejectionSymbol

Örökölt forrás InternalClient.captureRejectionSymbol

defaultMaxListeners

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

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

Ez nem egy kemény korlát. A EventEmitter példány több figyelő hozzáadását teszi lehetővé, de nyomkövetési figyelmeztetést küld az stderrnek, amely azt jelzi, hogy "lehetséges EventEmitter memóriavesztés" észlelhető. A és emitter.setMaxListeners() a emitter.getMaxListeners() metódusok használatával EventEmitterideiglenesen elkerülheti ezt 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ítheti az ilyen figyelmeztetések veremkövetését.

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

static defaultMaxListeners: number

Tulajdonság értéke

number

Örökölt forrás InternalClient.defaultMaxListeners

errorMonitor

Ezt a szimbólumot csak figyelési 'error' események figyelőjének telepítéséhez kell használni. Az ezzel a szimbólummal telepített figyelők a normál 'error' figyelők hívása előtt lesznek meghívva.

Ha figyelőt telepít ezzel a szimbólummal, az nem változtatja meg a viselkedést az 'error' esemény kibocsátása után. Ezért a folyamat továbbra is összeomlik, ha nincs rendszeres 'error' figyelő telepítve.

static errorMonitor: typeof errorMonitor

Tulajdonság értéke

typeof errorMonitor

Örökölt forrás InternalClient.errorMonitor

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 karakterlánc a megadott átviteli típus használatával.

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

Paraméterek

connStr

string

Egy kapcsolati karakterlánc, 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 egy környezeti változó neve EdgeHubConnectionString vagy IotHubConnectionString létezik, akkor a rendszer ezt az értéket használja, és a viselkedése megegyezik a bemenő hívással fromConnectionString . 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 megosztott 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

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, amelyet hibaobjektummal vagy a metódushívás eredményével hív meg a rendszer.

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 nevű metódus methodNamevisszahí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>

Függvény, amelyet akkor kell meghívni, amikor a metódusra methodName vonatkozó metóduskérés érkezik.

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

Az adott kimenetre küldendő üzenet

callback

Callback<MessageEnqueued>

Nem kötelező függvény hívása 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ények tömbjének 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>

Függvény a műveletek várólistára helyezésekor hívható meg.

setOptions(DeviceClientOptions) 

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

Paraméterek

options
DeviceClientOptions

Válaszok

Promise<TransportConfigured>

setOptions(DeviceClientOptions, Callback<TransportConfigured>)

Az átvitel konfigurálásához használható beállításokat ModuleClient adja át az objektumnak.

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

Paraméterek

options
DeviceClientOptions

DeviceClientOptions objektum.

done

Callback<TransportConfigured>

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

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

abandon(Message) 

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

Paraméterek

message
Message

Válaszok

Promise<MessageAbandoned>

Örökölt forrás InternalClient.abandon

abandon(Message, Callback<MessageAbandoned>) 

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

Paraméterek

message
Message
abandonCallback

Callback<MessageAbandoned>

Örökölt forrás InternalClient.abandon

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

Egyszer hallgatja meg az eseményt abort a megadott signalwebhelyen.

abort Az esemény megszakítási jeleken való hallgatása nem biztonságos, és erőforrás-szivárgáshoz vezethet, mivel egy másik, a jellel rendelkező harmadik fél meghívhatja a következőte.stopImmediatePropagation(): . Sajnos Node.js nem módosíthatja ezt, mivel ez sértené 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 az s biztonságos használatát AbortSignalNode.js API-kban, ha ezt a két problémát úgy oldja meg, hogy meghallgatja az eseményt, ami 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 figyelőt abort .

Örökölt forrás InternalClient.addAbortListener

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

Örökölt forrás InternalClient.addListener

complete(Message) 

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

Paraméterek

message
Message

Válaszok

Promise<MessageCompleted>

Örökölt forrás InternalClient.complete

complete(Message, Callback<MessageCompleted>) 

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

Paraméterek

message
Message
completeCallback

Callback<MessageCompleted>

Örökölt forrás InternalClient.complete

emit<K>(string | symbol, AnyRest)

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

Akkor ad true vissza, ha az eseménynek voltak figyelői, 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

Örökölt forrás InternalClient.emit

eventNames()

Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez a kibocsátó regisztrált figyelőket tartalmaz. 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)[]

Örökölt forrás InternalClient.eventNames

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

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

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

Az s esetében EventTargetez az egyetlen módja annak, hogy lekérje az eseménycél eseményfigyelőit. 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[]

Örökölt forrás InternalClient.getEventListeners

getMaxListeners()

Az aktuális maximális figyelőértéket adja vissza, EventEmitter amelynek emitter.setMaxListeners(n) alapértelmezett vagy alapértelmezett értéke a DefaultMaxListeners.

function getMaxListeners(): number

Válaszok

number

Örökölt forrás InternalClient.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

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

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

Az s esetében EventTargetez az egyetlen módja annak, hogy lekérje az eseménycélhoz tartozó maximális eseményfigyelőket. 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

Örökölt forrás InternalClient.getMaxListeners

getTwin() 

function getTwin(): Promise<Twin>

Válaszok

Promise<Twin>

Örökölt forrás InternalClient.getTwin

getTwin(Callback<Twin>) 

function getTwin(done: Callback<Twin>)

Paraméterek

done

Callback<Twin>

Örökölt forrás InternalClient.getTwin

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Figyelmeztetés

Ez az API már elavult.

Since v3.2.0 - Use listenerCount instead.

Osztálymetódus, amely a megadott eventName regisztrált figyelők számát adja vissza az adott emitterrendszeren.

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

Örökölt forrás InternalClient.listenerCount

listenerCount<K>(string | symbol, Function)

A nevű eseményt eventNamefigyelő figyelők számát adja vissza. Ha listener meg van adva, 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

Örökölt forrás InternalClient.listenerCount

listeners<K>(string | symbol)

A nevű esemény eventNamefigyelő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[]

Örökölt forrás InternalClient.listeners

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

Örökölt forrás 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

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

Az eseményekre AbortSignal való várakozás megszakításához 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());

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

Paraméterek

emitter

EventEmitter<DefaultEventMap>

eventName

string

A figyelt esemény neve

options

StaticEventEmitterOptions

Válaszok

AsyncIterableIterator<any>

Egy AsyncIterator , amely iterálja eventName a emitter

Örökölt forrás InternalClient.on

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

Hozzáadja a listener függvényt a nevű esemény eventNamefigyelőtömbjének végéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadva van-e. Több hívás, amely ugyanazt a kombinációt eventName adja át, és listener ennek eredményeként a listener rendszer többször is hozzáadja és meghívja őket.

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

A parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhí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

Örökölt forrás InternalClient.on

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

Olyan eseményt Promise hoz létre, amely akkor teljesül, ha az EventEmitter adott eseményt bocsátja ki, vagy ha a kibocsátja 'error' a EventEmitter várakozás közben. A Promise feloldás az adott eseménynek kibocsátott összes argumentum tömbjével oldható fel.

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

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

const ee = new EventEmitter();

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

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

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

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

Az esemény speciális kezelését 'error' csak akkor használja a rendszer, ha events.once() egy másik eseményre vár. Ha events.once() magát azerror' eseményt várja meg, akkor a rendszer bármilyen más típusú eseményként kezeli, különös 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

Az AbortSignal eseményre való várakozás megszakításához 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[]>

Örökölt forrás InternalClient.once

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

Örökölt forrás InternalClient.once

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

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

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

A parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhí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

Örökölt forrás InternalClient.once

open() 

function open(): Promise<Connected>

Válaszok

Promise<Connected>

Örökölt forrás InternalClient.open

open(Callback<Connected>) 

function open(openCallback: Callback<Connected>)

Paraméterek

openCallback

Callback<Connected>

Örökölt forrás InternalClient.open

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

Hozzáadja a listener függvényt a nevű esemény eventNamefigyelőtömbjének elejéhez. Nem történik ellenőrzés annak ellenőrzésére, hogy a listener már hozzáadva van-e. Több hívás, amely ugyanazt a kombinációt eventName adja át, és listener ennek eredményeként a listener rendszer többször is hozzáadja és meghívja őket.

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

A parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhí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

Örökölt forrás InternalClient.prependListener

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

Hozzáad egy egyszerilistener függvényt a nevesített eventName eseményhez a figyelőtömb elejéhez . A következő aktiváláskor eventName a figyelő el lesz távolítva, majd meghívódik.

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

A parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhí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

Örökölt forrás InternalClient.prependOnceListener

rawListeners<K>(string | symbol)

Visszaadja az esemény eventNamefigyelőinek tömbjének másolatát, beleértve a burkolókat is (például a által .once()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[]

Örökölt forrás InternalClient.rawListeners

reject(Message) 

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

Paraméterek

message
Message

Válaszok

Promise<MessageRejected>

Örökölt forrás InternalClient.reject

reject(Message, Callback<MessageRejected>) 

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

Paraméterek

message
Message
rejectCallback

Callback<MessageRejected>

Örökölt forrás InternalClient.reject

removeAllListeners(string | symbol)

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

Helytelen gyakorlat eltávolítani a kód más részeihez 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 parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhívások láncoltak legyenek.

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

Paraméterek

eventName

string | symbol

Válaszok

ModuleClient

Örökölt forrás InternalClient.removeAllListeners

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

Eltávolítja a megadott listener értéket a nevű eventNameesemé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 egy figyelőt többször is hozzáadtak a megadott eventNamefigyelőtömbhöz, akkor removeListener() az egyes példányok eltávolításához többször kell meghívni őket.

Az esemény kibocsátása után a rendszer sorrendben meghívja az ahhoz a kibocsátáskor csatolt összes figyelőt. Ez azt jelenti, hogy a removeListener() kibocsátás után és removeAllListeners() az utolsó figyelő végrehajtása előtt a hívások nem távolítják el őket a folyamatban lévőbőlemit(). 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, ez a hívás megváltoztatja a figyelő eltávolítása után regisztrált figyelők pozícióindexeit. Ez nem befolyásolja a figyelők hívásának sorrendjét, de ez azt jelenti, hogy a metódus által emitter.listeners() visszaadott figyelőtömb minden példányát ú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() a rendszer 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 parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhí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

Örökölt forrás InternalClient.removeListener

sendEvent(Message) 

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

Paraméterek

message
Message

Válaszok

Promise<MessageEnqueued>

Örökölt forrás InternalClient.sendEvent

sendEvent(Message, Callback<MessageEnqueued>) 

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

Paraméterek

message
Message
sendEventCallback

Callback<MessageEnqueued>

Örökölt forrás InternalClient.sendEvent

sendEventBatch(Message[]) 

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

Paraméterek

messages

Message[]

Válaszok

Promise<MessageEnqueued>

Örökölt forrás InternalClient.sendEventBatch

sendEventBatch(Message[], Callback<MessageEnqueued>) 

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

Paraméterek

messages

Message[]

sendEventBatchCallback

Callback<MessageEnqueued>

Örökölt forrás InternalClient.sendEventBatch

setMaxListeners(number)

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

A parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhívások láncoltak legyenek.

function setMaxListeners(n: number): ModuleClient

Paraméterek

n

number

Válaszok

ModuleClient

Örökölt forrás 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)[])

Paraméterek

n

number

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

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

Örökölt forrás InternalClient.setMaxListeners

setRetryPolicy(RetryPolicy)

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

function setRetryPolicy(policy: RetryPolicy)

Paraméterek

policy

RetryPolicy

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

Örökölt forrás InternalClient.setRetryPolicy

setTransportOptions(any) 

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

Paraméterek

options

any

Válaszok

Promise<TransportConfigured>

Örökölt forrás InternalClient.setTransportOptions

setTransportOptions(any, Callback<TransportConfigured>) 

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

Paraméterek

options

any

done

Callback<TransportConfigured>

Örökölt forrás InternalClient.setTransportOptions

updateSharedAccessSignature(string, Callback<SharedAccessSignatureUpdated>) 

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

Paraméterek

sharedAccessSignature

string

updateSasCallback

Callback<SharedAccessSignatureUpdated>

Örökölt forrás InternalClient.updateSharedAccessSignature

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