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

AmqpWs class

  • Referencia
Csomag:
azure-iothub

A szolgáltatásügyfél által használt átviteli osztály csatlakozni az Azure IoT Hubhoz az AMQP protokoll használatával biztonságos websocketeken keresztül. Ezt az osztályt nem szabad közvetlenül használni, hanem át kell adni az egyik Client gyári metódusnak: aConnectionString vagy fromSharedAccessSignature.

Extends
Amqp

Örökölt tulajdonságok

captureRejections

Érték: logikai

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

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

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

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

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

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

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

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

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

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

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

Örökölt metódusok

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

Egyszer meghallgatja a megadott abortsignal eseményt.

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

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

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

import { addAbortListener } from 'node:events';

function example(signal) {
  let disposable;
  try {
    signal.addEventListener('abort', (e) => e.stopImmediatePropagation());
    disposable = addAbortListener(signal, (e) => {
      // Do something when signal is aborted.
    });
  } finally {
    disposable?.[Symbol.dispose]();
  }
}
addListener<K>(string | symbol, (args: any[]) => void)

Alias a következőhöz emitter.on(eventName, listener): .
emit<K>(string | symbol, AnyRest)

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

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

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

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

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

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

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

Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket. A tömb értékei sztringek vagy Symbols.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
getEventListeners(EventEmitter<DefaultEventMap> | EventTarget, string | symbol)

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

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

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

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

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}
getMaxListeners()

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

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

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

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

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

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

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

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2
listenerCount<K>(string | symbol, Function)

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

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

server.on('connection', (stream) => {
  console.log('someone connected!');
});
console.log(util.inspect(server.listeners('connection')));
// Prints: [ [Function] ]
off<K>(string | symbol, (args: any[]) => void)

Alias a következőhöz emitter.removeListener(): .
on(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions) 
import { on, EventEmitter } from 'node:events';
import process from 'node:process';

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

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

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

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

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

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

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

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'
on(EventTarget, string, StaticEventEmitterIteratorOptions)
on<K>(string | symbol, (args: any[]) => void)

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

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

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

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

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a
once(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterOptions)

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

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

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

const ee = new EventEmitter();

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

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

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

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

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

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

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

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

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

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!
once(EventTarget, string, StaticEventEmitterOptions)
once<K>(string | symbol, (args: any[]) => void)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

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

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

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

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

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

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

A EventEmittermutató hivatkozást ad vissza, hogy a hívások láncoltak legyenek.
setMaxListeners(number, (EventEmitter<DefaultEventMap> | EventTarget)[]) 
import { setMaxListeners, EventEmitter } from 'node:events';

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

setMaxListeners(5, target, emitter);
[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öltAmqp.captureRejections

captureRejectionSymbol

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

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

static captureRejectionSymbol: typeof captureRejectionSymbol

Tulajdonság értéke

typeof captureRejectionSymbol

ÖrököltAmqp.captureRejectionSymbol

defaultMaxListeners

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

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

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

import { EventEmitter } from 'node:events';
const emitter = new EventEmitter();
emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

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

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

static defaultMaxListeners: number

Tulajdonság értéke

number

ÖrököltAmqp.defaultMaxListeners

errorMonitor

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

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

static errorMonitor: typeof errorMonitor

Tulajdonság értéke

typeof errorMonitor

ÖrököltAmqp.errorMonitor

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

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

Egyszer meghallgatja a megadott abortsignal eseményt.

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

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

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

import { addAbortListener } from 'node:events';

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

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

Paraméterek

signal

AbortSignal

resource

(event: Event) => void

Válaszok

Disposable

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

ÖrököltAmqp.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): AmqpWs

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

AmqpWs

ÖrököltAmqp.addListener

emit<K>(string | symbol, AnyRest)

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

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

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

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

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

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

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

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

Paraméterek

eventName

string | symbol

args

AnyRest

Válaszok

boolean

ÖrököltAmqp.bocsát ki

eventNames()

Egy tömböt ad vissza, amely felsorolja azokat az eseményeket, amelyekhez az emitter regisztrált figyelőket. A tömb értékei sztringek vagy Symbols.

import { EventEmitter } from 'node:events';

const myEE = new EventEmitter();
myEE.on('foo', () => {});
myEE.on('bar', () => {});

const sym = Symbol('symbol');
myEE.on(sym, () => {});

console.log(myEE.eventNames());
// Prints: [ 'foo', 'bar', Symbol(symbol) ]

function eventNames(): (string | symbol)[]

Válaszok

(string | symbol)[]

ÖrököltAmqp.eventNames

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

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

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

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

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

{
  const ee = new EventEmitter();
  const listener = () => console.log('Events are fun');
  ee.on('foo', listener);
  console.log(getEventListeners(ee, 'foo')); // [ [Function: listener] ]
}
{
  const et = new EventTarget();
  const listener = () => console.log('Events are fun');
  et.addEventListener('foo', listener);
  console.log(getEventListeners(et, 'foo')); // [ [Function: listener] ]
}

static function getEventListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget, name: string | symbol): Function[]

Paraméterek

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

Válaszok

Function[]

ÖrököltAmqp.getEventListeners

getMaxListeners()

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

function getMaxListeners(): number

Válaszok

number

örököltAmqp.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

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

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

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

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

{
  const ee = new EventEmitter();
  console.log(getMaxListeners(ee)); // 10
  setMaxListeners(11, ee);
  console.log(getMaxListeners(ee)); // 11
}
{
  const et = new EventTarget();
  console.log(getMaxListeners(et)); // 10
  setMaxListeners(11, et);
  console.log(getMaxListeners(et)); // 11
}

static function getMaxListeners(emitter: EventEmitter<DefaultEventMap> | EventTarget): number

Paraméterek

emitter

EventEmitter<DefaultEventMap> | EventTarget

Válaszok

number

örököltAmqp.getMaxListeners

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Figyelmeztetés

Ez az API már elavult.

Since v3.2.0 - Use listenerCount instead.

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

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

const myEmitter = new EventEmitter();
myEmitter.on('event', () => {});
myEmitter.on('event', () => {});
console.log(listenerCount(myEmitter, 'event'));
// Prints: 2

static function listenerCount(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol): number

Paraméterek

emitter

EventEmitter<DefaultEventMap>

A lekérdezendő emitter

eventName

string | symbol

Az esemény neve

Válaszok

number

ÖrököltAmqp.listenerCount

listenerCount<K>(string | symbol, Function)

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

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

Paraméterek

eventName

string | symbol

A figyelt esemény neve

listener

Function

Az eseménykezelő függvény

Válaszok

number

ÖrököltAmqp.listenerCount

listeners<K>(string | symbol)

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

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

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

Paraméterek

eventName

string | symbol

Válaszok

Function[]

ÖrököltAmqp.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): AmqpWs

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

AmqpWs

örököltAmqp.off

on(EventEmitter<DefaultEventMap>, string | symbol, StaticEventEmitterIteratorOptions) 

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

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
});

for await (const event of on(ee, 'foo')) {
  // The execution of this inner block is synchronous and it
  // processes one event at a time (even with await). Do not use
  // if concurrent execution is required.
  console.log(event); // prints ['bar'] [42]
}
// Unreachable here

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

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

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

const ac = new AbortController();

(async () => {
  const ee = new EventEmitter();

  // Emit later on
  process.nextTick(() => {
    ee.emit('foo', 'bar');
    ee.emit('foo', 42);
  });

  for await (const event of on(ee, 'foo', { signal: ac.signal })) {
    // The execution of this inner block is synchronous and it
    // processes one event at a time (even with await). Do not use
    // if concurrent execution is required.
    console.log(event); // prints ['bar'] [42]
  }
  // Unreachable here
})();

process.nextTick(() => ac.abort());

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

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

const ee = new EventEmitter();

// Emit later on
process.nextTick(() => {
  ee.emit('foo', 'bar');
  ee.emit('foo', 42);
  ee.emit('close');
});

for await (const event of on(ee, 'foo', { close: ['close'] })) {
  console.log(event); // prints ['bar'] [42]
}
// the loop will exit after 'close' is emitted
console.log('done'); // prints 'done'

static function on(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterIteratorOptions): AsyncIterator<any[], any, any>

Paraméterek

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

Válaszok

AsyncIterator<any[], any, any>

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

ÖrököltAmqp.on

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

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

Paraméterek

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

Válaszok

AsyncIterator<any[], any, any>

ÖrököltAmqp.on

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

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

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

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

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

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

AmqpWs

ÖrököltAmqp.on

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

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

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

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

const ee = new EventEmitter();

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

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

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

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

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

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

const ee = new EventEmitter();

once(ee, 'error')
  .then(([err]) => console.log('ok', err.message))
  .catch((err) => console.error('error', err.message));

ee.emit('error', new Error('boom'));

// Prints: ok boom

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

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

const ee = new EventEmitter();
const ac = new AbortController();

async function foo(emitter, event, signal) {
  try {
    await once(emitter, event, { signal });
    console.log('event emitted!');
  } catch (error) {
    if (error.name === 'AbortError') {
      console.error('Waiting for the event was canceled!');
    } else {
      console.error('There was an error', error.message);
    }
  }
}

foo(ee, 'foo', ac.signal);
ac.abort(); // Abort waiting for the event
ee.emit('foo'); // Prints: Waiting for the event was canceled!

static function once(emitter: EventEmitter<DefaultEventMap>, eventName: string | symbol, options?: StaticEventEmitterOptions): Promise<any[]>

Paraméterek

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

Válaszok

Promise<any[]>

örököltAmqp.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öltAmqp.once

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

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

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

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

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

import { EventEmitter } from 'node:events';
const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

AmqpWs

örököltAmqp.once

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

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

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

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

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

AmqpWs

ÖrököltAmqp.prependListener

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

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

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

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

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

Paraméterek

eventName

string | symbol

Az esemény neve.

listener

(args: any[]) => void

A visszahívási függvény

Válaszok

AmqpWs

ÖrököltAmqp.prependOnceListener

rawListeners<K>(string | symbol)

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

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

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

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

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

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

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

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

Paraméterek

eventName

string | symbol

Válaszok

Function[]

ÖrököltAmqp.rawListeners

removeAllListeners(string | symbol)

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

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

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

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

Paraméterek

eventName

string | symbol

Válaszok

AmqpWs

ÖrököltAmqp.removeAllListeners

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

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

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

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

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

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

const callbackA = () => {
  console.log('A');
  myEmitter.removeListener('event', callbackB);
};

const callbackB = () => {
  console.log('B');
};

myEmitter.on('event', callbackA);

myEmitter.on('event', callbackB);

// callbackA removes listener callbackB but it will still be called.
// Internal listener array at time of emit [callbackA, callbackB]
myEmitter.emit('event');
// Prints:
//   A
//   B

// callbackB is now removed.
// Internal listener array [callbackA]
myEmitter.emit('event');
// Prints:
//   A

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

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

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

function pong() {
  console.log('pong');
}

ee.on('ping', pong);
ee.once('ping', pong);
ee.removeListener('ping', pong);

ee.emit('ping');
ee.emit('ping');

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

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

Paraméterek

eventName

string | symbol

listener

(args: any[]) => void

Válaszok

AmqpWs

ÖrököltAmqp.removeListener

setMaxListeners(number)

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

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

function setMaxListeners(n: number): AmqpWs

Paraméterek

n

number

Válaszok

AmqpWs

ÖrököltAmqp.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 EventTarget eseményenként.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

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

ÖrököltAmqp.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öltAmqp. [captureRejectionSymbol]