Udostępnij za pośrednictwem

Twin class

  • Odwołanie
Pakiet:
azure-iot-device

Bliźniacze reprezentacje urządzenia to dokument opisujący stan urządzenia przechowywanego przez centrum Azure IoT Hub i jest dostępny nawet wtedy, gdy urządzenie jest w trybie offline. Jest zbudowany w około 3 sekcjach:

  • Tagi: pary klucz/wartość są dostępne tylko po stronie usługi
  • Żądane właściwości: zaktualizowane przez usługę i odebrane przez urządzenie
  • Zgłoszone właściwości: zaktualizowane przez urządzenie i odebrane przez usługę.

Należy pamiętać, że chociaż jest to możliwe, żądane i zgłoszone właściwości nie muszą być zgodne i że logika do synchronizacji tych dwóch kolekcji, w razie potrzeby, jest pozostawiona użytkownikowi zestawu SDK.

Aby uzyskać więcej informacji, zobacz Understanding Device Twins.

Rozszerzenie

EventEmitter

Właściwości

desiredPath
errorEvent
properties

Żądane i zgłoszone słowniki właściwości (odpowiednio w properties.desired i properties.reported).
userRegisteredDesiredPropertiesListener

Właściwości dziedziczone

captureRejections

Wartość: wartość logiczna

Zmień domyślną opcję captureRejections dla wszystkich nowych obiektów EventEmitter.
captureRejectionSymbol

Wartość: Symbol.for('nodejs.rejection')

Zobacz, jak napisać niestandardowy rejection handler.
defaultMaxListeners

Domyślnie dla dowolnego pojedynczego zdarzenia można zarejestrować maksymalnie 10 odbiorników. Ten limit można zmienić dla poszczególnych wystąpień EventEmitter przy użyciu metody emitter.setMaxListeners(n). Aby zmienić ustawienie domyślne dla wszystkich wystąpieńEventEmitter, można użyć właściwości events.defaultMaxListeners. Jeśli ta wartość nie jest liczbą dodatnią, zostanie zgłoszony RangeError.

Należy zachować ostrożność podczas ustawiania events.defaultMaxListeners, ponieważ zmiana ma wpływ na wszystkich wystąpieńEventEmitter, w tym utworzonych przed wprowadzeniem zmiany. Jednak wywołanie emitter.setMaxListeners(n) nadal ma pierwszeństwo przed events.defaultMaxListeners.

To nie jest twardy limit. Wystąpienie EventEmitter umożliwi dodanie większej liczby odbiorników, ale wyświetli ostrzeżenie śledzenia do stderr wskazujące, że wykryto "możliwy wyciek pamięci eventEmitter". W przypadku dowolnego pojedynczego EventEmittermożna użyć metod emitter.getMaxListeners() i emitter.setMaxListeners(), aby tymczasowo uniknąć tego ostrzeżenia:

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

Flaga wiersza polecenia --trace-warnings może służyć do wyświetlania śladu stosu dla takich ostrzeżeń.

Emitowane ostrzeżenie można sprawdzić za pomocą process.on('warning') i będzie mieć dodatkowe emitter, typei count właściwości, odwołując się do wystąpienia emitera zdarzeń, nazwy zdarzenia i liczby dołączonych odbiorników, odpowiednio. Właściwość name jest ustawiona na wartość 'MaxListenersExceededWarning'.
errorMonitor

Ten symbol służy do instalowania odbiornika tylko do monitorowania zdarzeń 'error'. Odbiorniki zainstalowane przy użyciu tego symbolu są wywoływane przed wywołaniami zwykłych odbiorników 'error'.

Instalowanie odbiornika przy użyciu tego symbolu nie zmienia zachowania po emitowaniu zdarzenia 'error'. W związku z tym proces będzie nadal ulegać awarii, jeśli nie zainstalowano zwykłego odbiornika 'error'.

Metody

get()
get(Callback<Twin>)

Pobiera całą reprezentację bliźniacze z usługi.

Metody dziedziczone

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

Nasłuchuje raz zdarzenia abort w podanym signal.

Nasłuchiwanie zdarzenia abort na sygnałach przerwania jest niebezpieczne i może prowadzić do wycieków zasobów, ponieważ inna firma z sygnałem może wywołać e.stopImmediatePropagation(). Niestety Node.js nie można tego zmienić, ponieważ narusza to standard sieci Web. Ponadto oryginalny interfejs API ułatwia zapominanie o usuwaniu odbiorników.

Ten interfejs API umożliwia bezpieczne korzystanie z AbortSignalw interfejsach API Node.js przez rozwiązanie tych dwóch problemów przez nasłuchiwanie zdarzenia, tak aby stopImmediatePropagation nie uniemożliwiał uruchamiania odbiornika.

Zwraca jednorazowy element, aby można było go łatwiej anulować.

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 dla emitter.on(eventName, listener).
emit<K>(string | symbol, AnyRest)

Synchronicznie wywołuje każdy odbiornik zarejestrowany dla zdarzenia o nazwie eventName, w kolejności, w której zostały zarejestrowane, przekazując podane argumenty do każdego.

Zwraca true, jeśli zdarzenie miało odbiorniki, false w przeciwnym razie.

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

Zwraca tablicę z listą zdarzeń, dla których emiter zarejestrował odbiorniki. Wartości w tablicy to ciągi lub 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)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

W przypadku EventEmitterdziała to dokładnie tak samo jak wywoływanie .listeners na emiterze.

W przypadku EventTargetjest to jedyny sposób uzyskiwania odbiorników zdarzeń dla obiektu docelowego zdarzenia. Jest to przydatne do celów debugowania i diagnostyki.

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

Zwraca bieżącą wartość maksymalnego odbiornika dla EventEmitter, która jest ustawiona przez emitter.setMaxListeners(n) lub domyślnie domyślneMaxListeners.
getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Zwraca obecnie ustawioną maksymalną ilość odbiorników.

W przypadku EventEmitterdziała to dokładnie tak samo jak wywoływanie .getMaxListeners na emiterze.

W przypadku EventTargetjest to jedyny sposób uzyskania maksymalnej liczby odbiorników zdarzeń dla celu zdarzenia. Jeśli liczba procedur obsługi zdarzeń w pojedynczym obiekcie EventTarget przekroczy maksymalny zestaw, usługa EventTarget wyświetli ostrzeżenie.

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)

Metoda klasy zwracająca liczbę odbiorników dla danego eventName zarejestrowanego w danym emitter.

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

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

Zwraca liczbę odbiorników nasłuchujących zdarzenia o nazwie eventName. W przypadku podania listener zostanie zwrócona liczba znalezionych odbiorników na liście odbiorników zdarzenia.
listeners<K>(string | symbol)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

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

Alias dla 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

Zwraca AsyncIterator, który iteruje eventName zdarzeń. Zostanie on zgłoszony, jeśli EventEmitter emituje 'error'. Usuwa wszystkie odbiorniki podczas zamykania pętli. value zwracana przez każdą iterację jest tablicą składającą się z emitowanych argumentów zdarzeń.

Za pomocą AbortSignal można anulować oczekiwanie na zdarzenia:

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

Użyj opcji close, aby określić tablicę nazw zdarzeń, które zakończą iterację:

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)

Dodaje funkcję listener na końcu tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

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)

Tworzy Promise, który jest spełniony, gdy EventEmitter emituje dane zdarzenie lub jest odrzucany, jeśli EventEmitter emituje 'error' podczas oczekiwania. Promise rozwiąże problem z tablicą wszystkich argumentów emitowanych do danego zdarzenia.

Ta metoda jest celowo ogólna i współpracuje z platformą internetową EventTarget interfejsu, który nie ma specjalnej semantyki zdarzeń'error' i nie nasłuchuje zdarzenia '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);
}

Specjalna obsługa zdarzenia 'error' jest używana tylko wtedy, gdy events.once() jest używana do oczekiwania na inne zdarzenie. Jeśli events.once() jest używana do oczekiwania na samo zdarzenieerror' , jest traktowany jako dowolny inny rodzaj zdarzenia bez specjalnej obsługi:

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

Za pomocą AbortSignal można anulować oczekiwanie na zdarzenie:

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)

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName. Przy następnym wyzwoleniu eventName ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependOnceListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

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)

Dodaje funkcję listener do rozpoczynającej się tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
prependOnceListener<K>(string | symbol, (args: any[]) => void)

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName do rozpoczynającej się tablicy odbiorników. Następnym razem, gdy eventName zostanie wyzwolony, ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
rawListeners<K>(string | symbol)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName, w tym wszelkie otoki (takie jak te utworzone przez .once()).

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

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

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

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

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

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

Usuwa wszystkie odbiorniki lub te z określonych eventName.

Źle jest usunąć odbiorniki dodane gdzie indziej w kodzie, szczególnie w przypadku utworzenia wystąpienia EventEmitter przez inny składnik lub moduł (np. gniazda lub strumienie plików).

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
removeListener<K>(string | symbol, (args: any[]) => void)

Usuwa określone listener z tablicy odbiorników dla zdarzenia o nazwie eventName.

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

removeListener() usunie co najwyżej jedno wystąpienie odbiornika z tablicy odbiornika. Jeśli jakikolwiek pojedynczy odbiornik został dodany wiele razy do tablicy odbiornika dla określonego eventName, removeListener() należy wywołać wiele razy, aby usunąć każde wystąpienie.

Po emitowaniu zdarzenia wszystkie odbiorniki dołączone do niego w momencie emitowania są wywoływane w kolejności. Oznacza to, że wszystkie wywołania removeListener() lub removeAllListeners()po emitowaniu i przed ostatnie wykonanie odbiornika nie spowoduje usunięcia ich zemit() w toku. Kolejne zdarzenia zachowują się zgodnie z oczekiwaniami.

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

Ponieważ odbiorniki są zarządzane przy użyciu tablicy wewnętrznej, wywołanie spowoduje zmianę indeksów pozycji dowolnego odbiornika zarejestrowanego po usunięcia odbiornika. Nie będzie to miało wpływu na kolejność wywoływanych odbiorników, ale oznacza to, że wszystkie kopie tablicy odbiorników zwrócone przez metodę emitter.listeners() będą musiały zostać ponownie odtworzone.

Gdy pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie), removeListener() usunie ostatnio dodane wystąpienie. W przykładzie odbiornik once('ping') zostanie usunięty:

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
setMaxListeners(number)

Domyślnie EventEmitters wyświetli ostrzeżenie, jeśli dla określonego zdarzenia zostanie dodane więcej niż 10 odbiorniki. Jest to przydatna wartość domyślna, która ułatwia znajdowanie przecieków pamięci. Metoda emitter.setMaxListeners() umożliwia zmodyfikowanie limitu dla tego konkretnego wystąpienia EventEmitter. Wartość można ustawić na Infinity (lub 0), aby wskazać nieograniczoną liczbę odbiorników.

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.
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)

Szczegóły właściwości

desiredPath 

static desiredPath: string

Wartość właściwości

string

errorEvent 

static errorEvent: string

Wartość właściwości

string

properties

Żądane i zgłoszone słowniki właściwości (odpowiednio w properties.desired i properties.reported).

properties: TwinProperties

Wartość właściwości

TwinProperties

userRegisteredDesiredPropertiesListener 

userRegisteredDesiredPropertiesListener: boolean

Wartość właściwości

boolean

Szczegóły właściwości dziedziczonej

captureRejections

Wartość: wartość logiczna

Zmień domyślną opcję captureRejections dla wszystkich nowych obiektów EventEmitter.

static captureRejections: boolean

Wartość właściwości

boolean

dziedziczone z EventEmitter.captureRejections

captureRejectionSymbol

Wartość: Symbol.for('nodejs.rejection')

Zobacz, jak napisać niestandardowy rejection handler.

static captureRejectionSymbol: typeof captureRejectionSymbol

Wartość właściwości

typeof captureRejectionSymbol

dziedziczone z EventEmitter.captureRejectionSymbol

defaultMaxListeners

Domyślnie dla dowolnego pojedynczego zdarzenia można zarejestrować maksymalnie 10 odbiorników. Ten limit można zmienić dla poszczególnych wystąpień EventEmitter przy użyciu metody emitter.setMaxListeners(n). Aby zmienić ustawienie domyślne dla wszystkich wystąpieńEventEmitter, można użyć właściwości events.defaultMaxListeners. Jeśli ta wartość nie jest liczbą dodatnią, zostanie zgłoszony RangeError.

Należy zachować ostrożność podczas ustawiania events.defaultMaxListeners, ponieważ zmiana ma wpływ na wszystkich wystąpieńEventEmitter, w tym utworzonych przed wprowadzeniem zmiany. Jednak wywołanie emitter.setMaxListeners(n) nadal ma pierwszeństwo przed events.defaultMaxListeners.

To nie jest twardy limit. Wystąpienie EventEmitter umożliwi dodanie większej liczby odbiorników, ale wyświetli ostrzeżenie śledzenia do stderr wskazujące, że wykryto "możliwy wyciek pamięci eventEmitter". W przypadku dowolnego pojedynczego EventEmittermożna użyć metod emitter.getMaxListeners() i emitter.setMaxListeners(), aby tymczasowo uniknąć tego ostrzeżenia:

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

Flaga wiersza polecenia --trace-warnings może służyć do wyświetlania śladu stosu dla takich ostrzeżeń.

Emitowane ostrzeżenie można sprawdzić za pomocą process.on('warning') i będzie mieć dodatkowe emitter, typei count właściwości, odwołując się do wystąpienia emitera zdarzeń, nazwy zdarzenia i liczby dołączonych odbiorników, odpowiednio. Właściwość name jest ustawiona na wartość 'MaxListenersExceededWarning'.

static defaultMaxListeners: number

Wartość właściwości

number

dziedziczone z EventEmitter.defaultMaxListeners

errorMonitor

Ten symbol służy do instalowania odbiornika tylko do monitorowania zdarzeń 'error'. Odbiorniki zainstalowane przy użyciu tego symbolu są wywoływane przed wywołaniami zwykłych odbiorników 'error'.

Instalowanie odbiornika przy użyciu tego symbolu nie zmienia zachowania po emitowaniu zdarzenia 'error'. W związku z tym proces będzie nadal ulegać awarii, jeśli nie zainstalowano zwykłego odbiornika 'error'.

static errorMonitor: typeof errorMonitor

Wartość właściwości

typeof errorMonitor

dziedziczone z EventEmitter.errorMonitor

Szczegóły metody

get() 

function get(): Promise<Twin>

Zwraca

Promise<Twin>

get(Callback<Twin>)

Pobiera całą reprezentację bliźniacze z usługi.

function get(callback?: Callback<Twin>)

Parametry

callback

Callback<Twin>

opcjonalna funkcja, która jest wywoływana z powrotem z bliźniaczą reprezentacją lub błędem, jeśli transport nie może pobrać bliźniaczej reprezentacji.

Szczegóły metody dziedziczonej

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

Nasłuchuje raz zdarzenia abort w podanym signal.

Nasłuchiwanie zdarzenia abort na sygnałach przerwania jest niebezpieczne i może prowadzić do wycieków zasobów, ponieważ inna firma z sygnałem może wywołać e.stopImmediatePropagation(). Niestety Node.js nie można tego zmienić, ponieważ narusza to standard sieci Web. Ponadto oryginalny interfejs API ułatwia zapominanie o usuwaniu odbiorników.

Ten interfejs API umożliwia bezpieczne korzystanie z AbortSignalw interfejsach API Node.js przez rozwiązanie tych dwóch problemów przez nasłuchiwanie zdarzenia, tak aby stopImmediatePropagation nie uniemożliwiał uruchamiania odbiornika.

Zwraca jednorazowy element, aby można było go łatwiej anulować.

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

Parametry

signal

AbortSignal

resource

(event: Event) => void

Zwraca

Disposable

Jednorazowe usunięcie odbiornika abort.

dziedziczone z EventEmitter.addAbortListener

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

Alias dla emitter.on(eventName, listener).

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

Twin

dziedziczone z EventEmitter.addListener

emit<K>(string | symbol, AnyRest)

Synchronicznie wywołuje każdy odbiornik zarejestrowany dla zdarzenia o nazwie eventName, w kolejności, w której zostały zarejestrowane, przekazując podane argumenty do każdego.

Zwraca true, jeśli zdarzenie miało odbiorniki, false w przeciwnym razie.

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

Parametry

eventName

string | symbol

args

AnyRest

Zwraca

boolean

dziedziczone z EventEmitter.emit

eventNames()

Zwraca tablicę z listą zdarzeń, dla których emiter zarejestrował odbiorniki. Wartości w tablicy to ciągi lub 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)[]

Zwraca

(string | symbol)[]

dziedziczone z EventEmitter.eventNames

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

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

W przypadku EventEmitterdziała to dokładnie tak samo jak wywoływanie .listeners na emiterze.

W przypadku EventTargetjest to jedyny sposób uzyskiwania odbiorników zdarzeń dla obiektu docelowego zdarzenia. Jest to przydatne do celów debugowania i diagnostyki.

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

Parametry

emitter

EventEmitter<DefaultEventMap> | EventTarget

name

string | symbol

Zwraca

Function[]

dziedziczone z EventEmitter.getEventListeners

getMaxListeners()

Zwraca bieżącą wartość maksymalnego odbiornika dla EventEmitter, która jest ustawiona przez emitter.setMaxListeners(n) lub domyślnie domyślneMaxListeners.

function getMaxListeners(): number

Zwraca

number

dziedziczone z EventEmitter.getMaxListeners

getMaxListeners(EventEmitter<DefaultEventMap> | EventTarget)

Zwraca obecnie ustawioną maksymalną ilość odbiorników.

W przypadku EventEmitterdziała to dokładnie tak samo jak wywoływanie .getMaxListeners na emiterze.

W przypadku EventTargetjest to jedyny sposób uzyskania maksymalnej liczby odbiorników zdarzeń dla celu zdarzenia. Jeśli liczba procedur obsługi zdarzeń w pojedynczym obiekcie EventTarget przekroczy maksymalny zestaw, usługa EventTarget wyświetli ostrzeżenie.

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

Parametry

emitter

EventEmitter<DefaultEventMap> | EventTarget

Zwraca

number

dziedziczone z EventEmitter.getMaxListeners

listenerCount(EventEmitter<DefaultEventMap>, string | symbol)

Ostrzeżenie

Ten interfejs API jest już przestarzały.

Since v3.2.0 - Use listenerCount instead.

Metoda klasy zwracająca liczbę odbiorników dla danego eventName zarejestrowanego w danym emitter.

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

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

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

Parametry

emitter

EventEmitter<DefaultEventMap>

Emiter do wykonywania zapytania

eventName

string | symbol

Nazwa zdarzenia

Zwraca

number

dziedziczone z EventEmitter.listenerCount

listenerCount<K>(string | symbol, Function)

Zwraca liczbę odbiorników nasłuchujących zdarzenia o nazwie eventName. W przypadku podania listener zostanie zwrócona liczba znalezionych odbiorników na liście odbiorników zdarzenia.

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

Parametry

eventName

string | symbol

Nazwa zdarzenia, dla których jest nasłuchiwane

listener

Function

Funkcja obsługi zdarzeń

Zwraca

number

dziedziczone z EventEmitter.listenerCount

listeners<K>(string | symbol)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName.

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

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

Parametry

eventName

string | symbol

Zwraca

Function[]

dziedziczone z EventEmitter.listeners

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

Alias dla emitter.removeListener().

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

Twin

dziedziczone z EventEmitter.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

Zwraca AsyncIterator, który iteruje eventName zdarzeń. Zostanie on zgłoszony, jeśli EventEmitter emituje 'error'. Usuwa wszystkie odbiorniki podczas zamykania pętli. value zwracana przez każdą iterację jest tablicą składającą się z emitowanych argumentów zdarzeń.

Za pomocą AbortSignal można anulować oczekiwanie na zdarzenia:

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

Użyj opcji close, aby określić tablicę nazw zdarzeń, które zakończą iterację:

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>

Parametry

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterIteratorOptions

Zwraca

AsyncIterator<any[], any, any>

AsyncIterator, który iteruje eventName zdarzenia emitowane przez emitter

dziedziczone z EventEmitter.on

on(EventTarget, string, StaticEventEmitterIteratorOptions) 

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

Parametry

emitter

EventTarget

eventName

string

options

StaticEventEmitterIteratorOptions

Zwraca

AsyncIterator<any[], any, any>

dziedziczone z EventEmitter.on

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

Dodaje funkcję listener na końcu tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

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

Parametry

eventName

string | symbol

Nazwa zdarzenia.

listener

(args: any[]) => void

Funkcja wywołania zwrotnego

Zwraca

Twin

dziedziczone z EventEmitter.on

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

Tworzy Promise, który jest spełniony, gdy EventEmitter emituje dane zdarzenie lub jest odrzucany, jeśli EventEmitter emituje 'error' podczas oczekiwania. Promise rozwiąże problem z tablicą wszystkich argumentów emitowanych do danego zdarzenia.

Ta metoda jest celowo ogólna i współpracuje z platformą internetową EventTarget interfejsu, który nie ma specjalnej semantyki zdarzeń'error' i nie nasłuchuje zdarzenia '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);
}

Specjalna obsługa zdarzenia 'error' jest używana tylko wtedy, gdy events.once() jest używana do oczekiwania na inne zdarzenie. Jeśli events.once() jest używana do oczekiwania na samo zdarzenieerror' , jest traktowany jako dowolny inny rodzaj zdarzenia bez specjalnej obsługi:

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

Za pomocą AbortSignal można anulować oczekiwanie na zdarzenie:

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

Parametry

emitter

EventEmitter<DefaultEventMap>

eventName

string | symbol

options

StaticEventEmitterOptions

Zwraca

Promise<any[]>

dziedziczone z EventEmitter.once

once(EventTarget, string, StaticEventEmitterOptions) 

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

Parametry

emitter

EventTarget

eventName

string

options

StaticEventEmitterOptions

Zwraca

Promise<any[]>

dziedziczone z EventEmitter.once

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

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName. Przy następnym wyzwoleniu eventName ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

Domyślnie odbiorniki zdarzeń są wywoływane w kolejności, w której są dodawane. Metodę emitter.prependOnceListener() można użyć jako alternatywy, aby dodać odbiornik zdarzeń na początku tablicy odbiorników.

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

Parametry

eventName

string | symbol

Nazwa zdarzenia.

listener

(args: any[]) => void

Funkcja wywołania zwrotnego

Zwraca

Twin

dziedziczone z EventEmitter.once

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

Dodaje funkcję listener do rozpoczynającej się tablicy odbiorników dla zdarzenia o nazwie eventName. Nie są sprawdzane, czy listener został już dodany. Wiele wywołań przekazujących tę samą kombinację eventName i listener spowoduje dodanie listener i wywołanie wielu razy.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

string | symbol

Nazwa zdarzenia.

listener

(args: any[]) => void

Funkcja wywołania zwrotnego

Zwraca

Twin

dziedziczone z EventEmitter.prependListener

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

Dodaje funkcję jednorazowąlistener dla zdarzenia o nazwie eventName do rozpoczynającej się tablicy odbiorników. Następnym razem, gdy eventName zostanie wyzwolony, ten odbiornik zostanie usunięty, a następnie wywołany.

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

string | symbol

Nazwa zdarzenia.

listener

(args: any[]) => void

Funkcja wywołania zwrotnego

Zwraca

Twin

dziedziczone z EventEmitter.prependOnceListener

rawListeners<K>(string | symbol)

Zwraca kopię tablicy odbiorników dla zdarzenia o nazwie eventName, w tym wszelkie otoki (takie jak te utworzone przez .once()).

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

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

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

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

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

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

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

Parametry

eventName

string | symbol

Zwraca

Function[]

dziedziczone z EventEmitter.rawListeners

removeAllListeners(string | symbol)

Usuwa wszystkie odbiorniki lub te z określonych eventName.

Źle jest usunąć odbiorniki dodane gdzie indziej w kodzie, szczególnie w przypadku utworzenia wystąpienia EventEmitter przez inny składnik lub moduł (np. gniazda lub strumienie plików).

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

string | symbol

Zwraca

Twin

dziedziczone z EventEmitter.removeAllListeners

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

Usuwa określone listener z tablicy odbiorników dla zdarzenia o nazwie eventName.

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

removeListener() usunie co najwyżej jedno wystąpienie odbiornika z tablicy odbiornika. Jeśli jakikolwiek pojedynczy odbiornik został dodany wiele razy do tablicy odbiornika dla określonego eventName, removeListener() należy wywołać wiele razy, aby usunąć każde wystąpienie.

Po emitowaniu zdarzenia wszystkie odbiorniki dołączone do niego w momencie emitowania są wywoływane w kolejności. Oznacza to, że wszystkie wywołania removeListener() lub removeAllListeners()po emitowaniu i przed ostatnie wykonanie odbiornika nie spowoduje usunięcia ich zemit() w toku. Kolejne zdarzenia zachowują się zgodnie z oczekiwaniami.

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

Ponieważ odbiorniki są zarządzane przy użyciu tablicy wewnętrznej, wywołanie spowoduje zmianę indeksów pozycji dowolnego odbiornika zarejestrowanego po usunięcia odbiornika. Nie będzie to miało wpływu na kolejność wywoływanych odbiorników, ale oznacza to, że wszystkie kopie tablicy odbiorników zwrócone przez metodę emitter.listeners() będą musiały zostać ponownie odtworzone.

Gdy pojedyncza funkcja została dodana jako procedura obsługi wiele razy dla pojedynczego zdarzenia (jak w poniższym przykładzie), removeListener() usunie ostatnio dodane wystąpienie. W przykładzie odbiornik once('ping') zostanie usunięty:

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

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

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

Parametry

eventName

string | symbol

listener

(args: any[]) => void

Zwraca

Twin

dziedziczone z EventEmitter.removeListener

setMaxListeners(number)

Domyślnie EventEmitters wyświetli ostrzeżenie, jeśli dla określonego zdarzenia zostanie dodane więcej niż 10 odbiorniki. Jest to przydatna wartość domyślna, która ułatwia znajdowanie przecieków pamięci. Metoda emitter.setMaxListeners() umożliwia zmodyfikowanie limitu dla tego konkretnego wystąpienia EventEmitter. Wartość można ustawić na Infinity (lub 0), aby wskazać nieograniczoną liczbę odbiorników.

Zwraca odwołanie do EventEmitter, aby wywołania mogły być łańcuchowe.

function setMaxListeners(n: number): Twin

Parametry

n

number

Zwraca

Twin

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

Parametry

n

number

Liczba nieujemna. Maksymalna liczba odbiorników na zdarzenie EventTarget.

eventTargets

(EventEmitter<DefaultEventMap> | EventTarget)[]

Zero lub więcej wystąpień {EventTarget} lub {EventEmitter}. Jeśli żadna z nich nie zostanie określona, n zostanie ustawiona jako domyślna wartość maksymalna dla wszystkich nowo utworzonych obiektów {EventTarget} i {EventEmitter}.

dziedziczone z EventEmitter.setMaxListeners

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

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

Parametry

error

Error

event

string | symbol

args

AnyRest

dziedziczone z EventEmitter.__@captureRejectionSymbol@141