Share via

SharedAccessKeyAuthenticationProvider class

  • Referencia
Csomag:
azure-iot-device

Olyan objektumot biztosít, amely egyszerűen létrehozható AuthenticationProvider egy kapcsolati karakterlánc, amelyet aztán az eszközügyfél használ, és az Azure IoT Hub-példánnyal való hitelesítéshez átvitelt biztosít.

Az SharedAccessKeyAuthenticationProvider objektum rendszeres időközönként gondoskodik a közös hozzáférésű jogosultságkód-jogkivonatok létrehozásáról, és kibocsátja az newTokenAvailable eseményt, hogy az átvitelek megújítsák hitelesítő adataikat az Azure IoT Hub-példánnyal, és kapcsolatban maradjanak.

Extends

EventEmitter

Tulajdonságok

type

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

Tekintse meg, hogyan írhat egyéni rejection handlerelemet.
defaultMaxListeners

Alapértelmezés szerint legfeljebb 10 figyelő regisztrálható egyetlen eseményhez. 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, akkor a RangeError lesz dobva.

A beállításánál events.defaultMaxListeners körültekintően járjon el, mert a módosítás az összesEventEmitter 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 -tal 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 a rendszer "lehetséges EventEmitter memóriavesztést" észlelt. A EventEmitterés emitter.setMaxListeners() a emitter.getMaxListeners() metódusok használatával ideiglenesen 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íthető az ilyen figyelmeztetések veremkövetése.

A kibocsátott figyelmeztetést megvizsgálhatja a következővel process.on('warning') : , és rendelkezik a további emitter, typeés count tulajdonságokkal, hivatkozva az esemény-kibocsátó példányra, az esemény nevére és a csatlakoztatott figyelők számára. A name tulajdonsága értékre 'MaxListenersExceededWarning'van állítva.
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 ezzel a szimbólummal telepít egy figyelőt, 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 telepítve normál 'error' figyelő.

Metódusok

fromConnectionString(string, number, number)

Új SharedAccessKeyAuthenticationProvider létrehozása kapcsolati karakterlánc
getDeviceCredentials()
getDeviceCredentials(Callback<TransportConfig>)

Ezt a módszert az átvitelek használják az eszköz legfrissebb hitelesítő adatainak lekéréséhez egy TransportConfig objektum formájában.
setTokenRenewalValues(number, number)

Ezzel a módszerrel a hívó új értékeket állíthat be a hitelesítés megújításához.

Ez a függvény szinkron módon fejeződik be, de a műveletek aszinkron módon történnek. Ha a szolgáltató már végez jogkivonat-megújításokat, például – ha hálózati kapcsolat lett létrehozva, a függvény meghívása szinte azonnal új megújítást eredményez. A protokolltól függően ez leválasztást és újracsatlakozást okozhat. Ha azonban a megújítások jelenleg NEM történnek meg, egyszerűen elmentjük az új értékeket későbbi használatra.
stop()

Leállítja az SAS-jogkivonatra való megújításhoz használt időzítőt.

Örökölt metódusok

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

Egyszer figyeli a abort megadott signaleseményt.

Az esemény megszakítási jeleken való figyelése abort nem biztonságos, és erőforrásszivárgáshoz vezethet, mivel a jellel rendelkező másik harmadik fél meghívhatja a következőt e.stopImmediatePropagation(): . Sajnos Node.js nem módosíthatja ezt, mert megsé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 azáltal, hogy ezt a két problémát úgy oldja meg, hogy figyeli az eseményt, ami stopImmediatePropagation nem akadályozza meg a figyelő futását.

Eldobható értéket ad vissza, így könnyebben leiratkozhat 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).
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.

Visszaadja true , ha az eseménynek voltak figyelői, false egyébként.

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. 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 EventTargets esetében ez 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 a beállítása vagy alapértelmezés szerint defaultMaxListeners értékre van állítvaemitter.setMaxListeners(n).
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él maximális eseményfigyelőit. Ha egy EventTarget eseménykezelőinek száma meghaladja a maximális készletet, az EventTarget figyelmeztetést jelenít meg.

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

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

Egy 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ű eventNameeseményt figyelő figyelők számát adja vissza. Ha listener meg van adva, a 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

Egy olyan értéket AsyncIterator ad vissza, amely iterálja az eventName eseményeket. Akkor dob, ha a EventEmitter bocsát ki '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á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());
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éhez, hogy a listener már hozzá lett-e adva. Több hívás, amely a és ugyanazon kombinációját eventName adja át, a listener és listener a többszörös hozzáadását és meghívását eredményezi.

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 a EventEmitter kibocsátja az adott eseményt, vagy ha a kibocsátja 'error' a EventEmitter várakozás közben. A Promise a 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 a webplatform EventTarget 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ése 'error' csak akkor használatos, ha events.once() egy másik eseményre való várakozásra szolgál. Ha events.once() magát azerror' eseményt várja meg, akkor speciális kezelés nélkül bármilyen más eseményként kezelik:

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
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éhez, hogy a listener már hozzá lett-e adva. Több hívás, amely a és ugyanazon kombinációját eventName adja át, a listener és listener a többszörös hozzáadását és meghívását eredményezi.

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)

A nevű esemény eventNamefigyelőinek tömbjének másolatát adja vissza, 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');
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é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 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 is meg kell hívni.

Az esemény kibocsátása után a rendszer a kibocsátáskor hozzá kapcsolt összes figyelőt sorrendben hívja meg. Ez azt jelenti, hogy a removeListener() kibocsátás után és removeAllListeners() az utolsó figyelő végrehajtása előtt indított hívások nem távolítják el őket a folyamatban lévőkbő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, 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 meghívásának sorrendjét, de ez azt jelenti, hogy a emitter.listeners() metódus által 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.
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é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ó (vagy 0) értékre Infinity , amely korlátlan számú figyelőt jelez.

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);
[captureRejectionSymbol]<K>(Error, string | symbol, AnyRest)

Tulajdonság adatai

type 

type: AuthenticationType

Tulajdonság értéke

AuthenticationType

Ö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 EventEmitter.captureRejections

captureRejectionSymbol

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

Tekintse meg, hogyan írhat egyéni rejection handlerelemet.

static captureRejectionSymbol: typeof captureRejectionSymbol

Tulajdonság értéke

typeof captureRejectionSymbol

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

defaultMaxListeners

Alapértelmezés szerint legfeljebb 10 figyelő regisztrálható egyetlen eseményhez. 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, akkor a RangeError lesz dobva.

A beállításánál events.defaultMaxListeners körültekintően járjon el, mert a módosítás az összesEventEmitter 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 -tal 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 a rendszer "lehetséges EventEmitter memóriavesztést" észlelt. A EventEmitterés emitter.setMaxListeners() a emitter.getMaxListeners() metódusok használatával ideiglenesen 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íthető az ilyen figyelmeztetések veremkövetése.

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

static defaultMaxListeners: number

Tulajdonság értéke

number

Örökölt forrás EventEmitter.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 ezzel a szimbólummal telepít egy figyelőt, 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 telepítve normál 'error' figyelő.

static errorMonitor: typeof errorMonitor

Tulajdonság értéke

typeof errorMonitor

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

Metódus adatai

fromConnectionString(string, number, number)

Új SharedAccessKeyAuthenticationProvider létrehozása kapcsolati karakterlánc

static function fromConnectionString(connectionString: string, tokenValidTimeInSeconds?: number, tokenRenewalMarginInSeconds?: number): SharedAccessKeyAuthenticationProvider

Paraméterek

connectionString

string

Az IoT Hubbal való hitelesítéshez szükséges paramétereket tartalmazó eszköz kapcsolati karakterlánc.

tokenValidTimeInSeconds

number

[nem kötelező] Az a másodpercszám, amelyre a jogkivonatnak érvényesnek kell lennie.

tokenRenewalMarginInSeconds

number

[nem kötelező] Az érvényességi időszak vége előtt másodpercek száma, amely alatt a SharedAccessKeyAuthenticationProvider jogkivonatot meg kell újítani.

Válaszok

SharedAccessKeyAuthenticationProvider

getDeviceCredentials() 

function getDeviceCredentials(): Promise<TransportConfig>

Válaszok

Promise<TransportConfig>

getDeviceCredentials(Callback<TransportConfig>)

Ezt a módszert az átvitelek használják az eszköz legfrissebb hitelesítő adatainak lekéréséhez egy TransportConfig objektum formájában.

function getDeviceCredentials(callback?: Callback<TransportConfig>)

Paraméterek

callback

Callback<TransportConfig>

opcionális függvény, amely egy hibával vagy az IoT Hubbal való hitelesítéshez használható eszközhitelesítő adatok készletével lesz meghívva.

setTokenRenewalValues(number, number)

Ezzel a módszerrel a hívó új értékeket állíthat be a hitelesítés megújításához.

Ez a függvény szinkron módon fejeződik be, de a műveletek aszinkron módon történnek. Ha a szolgáltató már végez jogkivonat-megújításokat, például – ha hálózati kapcsolat lett létrehozva, a függvény meghívása szinte azonnal új megújítást eredményez. A protokolltól függően ez leválasztást és újracsatlakozást okozhat. Ha azonban a megújítások jelenleg NEM történnek meg, egyszerűen elmentjük az új értékeket későbbi használatra.

function setTokenRenewalValues(tokenValidTimeInSeconds: number, tokenRenewalMarginInSeconds: number)

Paraméterek

tokenValidTimeInSeconds

number

Az a másodpercszám, amelyre a jogkivonatnak érvényesnek kell lennie.

tokenRenewalMarginInSeconds

number

Az érvényességi időszak vége előtt másodpercek száma, amely alatt a SharedAccessKeyAuthenticationProvider jogkivonatot meg kell újítani.

stop()

Leállítja az SAS-jogkivonatra való megújításhoz használt időzítőt.

function stop()

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

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

Egyszer figyeli a abort megadott signaleseményt.

Az esemény megszakítási jeleken való figyelése abort nem biztonságos, és erőforrásszivárgáshoz vezethet, mivel a jellel rendelkező másik harmadik fél meghívhatja a következőt e.stopImmediatePropagation(): . Sajnos Node.js nem módosíthatja ezt, mert megsé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 azáltal, hogy ezt a két problémát úgy oldja meg, hogy figyeli az eseményt, ami stopImmediatePropagation nem akadályozza meg a figyelő futását.

Eldobható értéket ad vissza, így könnyebben leiratkozhat 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ó, ami eltávolítja a figyelőt abort .

Örökölt forrás EventEmitter.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): SharedAccessKeyAuthenticationProvider

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

SharedAccessKeyAuthenticationProvider

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

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.

Visszaadja true , ha az eseménynek voltak figyelői, false egyébként.

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 EventEmitter.emit

eventNames()

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

Örökölt forrás EventEmitter.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 EventTargets esetében ez 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 EventEmitter.getEventListeners

getMaxListeners()

Az aktuális maximális figyelőértéket adja vissza, EventEmitter amelynek a beállítása vagy alapértelmezés szerint defaultMaxListeners értékre van állítvaemitter.setMaxListeners(n).

function getMaxListeners(): number

Válaszok

number

Örökölt forrás EventEmitter.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él maximális eseményfigyelőit. Ha egy EventTarget eseménykezelőinek száma meghaladja a maximális készletet, az EventTarget figyelmeztetést jelenít meg.

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 EventEmitter.getMaxListeners

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Figyelmeztetés

Ez az API már elavult.

Since v3.2.0 - Use listenerCount instead.

Egy 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 EventEmitter.listenerCount

listenerCount<K>(string | symbol, Function)

A nevű eventNameeseményt figyelő figyelők számát adja vissza. Ha listener meg van adva, a 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 EventEmitter.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 EventEmitter.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): SharedAccessKeyAuthenticationProvider

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

SharedAccessKeyAuthenticationProvider

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

Egy olyan értéket AsyncIterator ad vissza, amely iterálja az eventName eseményeket. Akkor dob, ha a EventEmitter bocsát ki '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á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());

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 az által kibocsátott eseményeket emitter

Örökölt forrás EventEmitter.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éhez, hogy a listener már hozzá lett-e adva. Több hívás, amely a és ugyanazon kombinációját eventName adja át, a listener és listener a többszörös hozzáadását és meghívását eredményezi.

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

SharedAccessKeyAuthenticationProvider

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

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

Olyan eseményt Promise hoz létre, amely akkor teljesül, ha a EventEmitter kibocsátja az adott eseményt, vagy ha a kibocsátja 'error' a EventEmitter várakozás közben. A Promise a 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 a webplatform EventTarget 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ése 'error' csak akkor használatos, ha events.once() egy másik eseményre való várakozásra szolgál. Ha events.once() magát azerror' eseményt várja meg, akkor speciális kezelés nélkül bármilyen más eseményként kezelik:

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 EventEmitter.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 EventEmitter.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): SharedAccessKeyAuthenticationProvider

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

SharedAccessKeyAuthenticationProvider

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

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éhez, hogy a listener már hozzá lett-e adva. Több hívás, amely a és ugyanazon kombinációját eventName adja át, a listener és listener a többszörös hozzáadását és meghívását eredményezi.

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

SharedAccessKeyAuthenticationProvider

Örökölt forrás EventEmitter.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): SharedAccessKeyAuthenticationProvider

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

SharedAccessKeyAuthenticationProvider

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

rawListeners<K>(string | symbol)

A nevű esemény eventNamefigyelőinek tömbjének másolatát adja vissza, 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 EventEmitter.rawListeners

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é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 parancsra mutató hivatkozást ad vissza, hogy a EventEmitterhívások láncoltak legyenek.

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

Paraméterek

eventName

string | symbol

Válaszok

SharedAccessKeyAuthenticationProvider

Örökölt forrás EventEmitter.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 is meg kell hívni.

Az esemény kibocsátása után a rendszer a kibocsátáskor hozzá kapcsolt összes figyelőt sorrendben hívja meg. Ez azt jelenti, hogy a removeListener() kibocsátás után és removeAllListeners() az utolsó figyelő végrehajtása előtt indított hívások nem távolítják el őket a folyamatban lévőkbő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, 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 meghívásának sorrendjét, de ez azt jelenti, hogy a emitter.listeners() metódus által 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): SharedAccessKeyAuthenticationProvider

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

SharedAccessKeyAuthenticationProvider

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

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é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ó (vagy 0) értékre Infinity , amely korlátlan számú figyelőt jelez.

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

function setMaxListeners(n: number): SharedAccessKeyAuthenticationProvider

Paraméterek

n

number

Válaszok

SharedAccessKeyAuthenticationProvider

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

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

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

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

setMaxListeners(5, target, emitter);

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

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 EventEmitter.setMaxListeners

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