События

Исходный код: lib/events.js

Большая часть ядра Node.js API построена вокруг идиоматичной асинхронной архитектуры обработки событий, в которой некоторые типы объектов (называемые "эмиттерами") излучают именованные события, вызывающие Function объекты ("слушатели").

Например: объект net.Server излучает событие каждый раз, когда к нему подключается узел; объект fs.ReadStream излучает событие при открытии файла; поток stream излучает событие всякий раз, когда данные доступны для чтения.

Все объекты, излучающие события, являются экземплярами класса EventEmitter. Эти объекты предоставляют функцию eventEmitter.on(), которая позволяет прикрепить одну или несколько функций к именованным событиям, излучаемым объектом. Обычно имена событий являются строками с верблюжьей нотацией, но может использоваться любой допустимый ключ JavaScript-свойства.

Когда объект EventEmitter излучает событие, все функции, прикрепленные к этому конкретному событию, вызываются синхронно. Любые значения, возвращаемые вызываемыми слушателями, игнорируются и будут удалены.

Следующий пример демонстрирует простой экземпляр EventEmitter с одним слушателем. Метод eventEmitter.on() используется для регистрации слушателей, а метод eventEmitter.emit() используется для запуска события.

const EventEmitter = require('events');

class MyEmitter extends EventEmitter {}

const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
  console.log('an event occurred!');
});
myEmitter.emit('event');

Передача аргументов и `this` слушателям

Метод eventEmitter.emit() позволяет передавать произвольное количество аргументов функциям-слушателям. Имейте в виду, что при вызове обычной функции-слушателя стандартное ключевое слово this преднамеренно устанавливается для ссылки на экземпляр EventEmitter , к которому прикреплен слушатель.

const myEmitter = new MyEmitter();
myEmitter.on('event', function(a, b) {
  console.log(a, b, this, this === myEmitter);
  // Prints:
  //   a b MyEmitter {
  //     domain: null,
  //     _events: { event: [Function] },
  //     _eventsCount: 1,
  //     _maxListeners: undefined } true
});
myEmitter.emit('event', 'a', 'b');

Можно использовать стрелочные функции ES6 в качестве слушателей, однако в этом случае ключевое слово this больше не будет ссылаться на экземпляр EventEmitter:

const myEmitter = new MyEmitter();
myEmitter.on('event', (a, b) => {
  console.log(a, b, this);
  // Prints: a b {}
});
myEmitter.emit('event', 'a', 'b');

Асинхронный и синхронный режимы

Метод EventEmitter вызывает всех слушателей синхронно в порядке их регистрации. Это гарантирует правильную последовательность событий и помогает избежать гонок и логических ошибок. При необходимости функции-слушатели могут переключаться на асинхронный режим работы, используя методы setImmediate() или process.nextTick():

const myEmitter = new MyEmitter();
myEmitter.on('event', (a, b) => {
  setImmediate(() => {
    console.log('this happens asynchronously');
  });
});
myEmitter.emit('event', 'a', 'b');

Обработка событий только один раз

Когда слушатель регистрируется с помощью метода eventEmitter.on() , этот слушатель будет вызываться каждый раз, когда излучается именованное событие.

const myEmitter = new MyEmitter();
let m = 0;
myEmitter.on('event', () => {
  console.log(++m);
});
myEmitter.emit('event');
// Prints: 1
myEmitter.emit('event');
// Prints: 2

Используя метод eventEmitter.once() , можно зарегистрировать слушателя, который вызывается не более одного раза для определенного события. После излучения события слушатель отключается и затем вызывается.

const myEmitter = new MyEmitter();
let m = 0;
myEmitter.once('event', () => {
  console.log(++m);
});
myEmitter.emit('event');
// Prints: 1
myEmitter.emit('event');
// Ignored

События ошибок

Когда в экземпляре EventEmitter возникает ошибка, типичным действием является излучение события 'error'. Они рассматриваются как особые случаи в Node.js.

Если у экземпляра EventEmitter нет хотя бы одного зарегистрированного слушателя для события 'error' и излучается событие 'error' , ошибка выбрасывается, выводится стек вызовов, и процесс Node.js завершается.

const myEmitter = new MyEmitter();
myEmitter.emit('error', new Error('whoops!'));
// Throws and crashes Node.js

Чтобы избежать аварийного завершения процесса Node.js, можно использовать модуль domain. (Обратите внимание, что модуль domain устарел.)

В качестве наилучшей практики, слушатели всегда должны добавляться для событий 'error'.

const myEmitter = new MyEmitter();
myEmitter.on('error', (err) => {
  console.error('whoops! there was an error');
});
myEmitter.emit('error', new Error('whoops!'));
// Prints: whoops! there was an error

Можно отслеживать события 'error' без потребления излучаемой ошибки, установив слушателя, используя символ errorMonitor.

const myEmitter = new MyEmitter();
myEmitter.on(EventEmitter.errorMonitor, (err) => {
  MyMonitoringTool.log(err);
});
myEmitter.emit('error', new Error('whoops!'));
// Still throws and crashes Node.js

Перехват отказов обещаний

Устойчивость: 1 - captureRejections — экспериментальная функция.

Использование async функций с обработчиками событий проблематично, поскольку это может привести к необработанному отказу в случае возникновения исключения:

const ee = new EventEmitter();
ee.on('something', async (value) => {
  throw new Error('kaboom');
});

Опция captureRejections в конструкторе EventEmitter или глобальная настройка изменяют это поведение, устанавливая обработчик .then(undefined, handler) для Promise. Этот обработчик асинхронно перенаправляет исключение в метод Symbol.for('nodejs.rejection'), если он существует, или в обработчик события 'error', если нет.

const ee1 = new EventEmitter({ captureRejections: true });
ee1.on('something', async (value) => {
  throw new Error('kaboom');
});

ee1.on('error', console.log);

const ee2 = new EventEmitter({ captureRejections: true });
ee2.on('something', async (value) => {
  throw new Error('kaboom');
});

ee2[Symbol.for('nodejs.rejection')] = console.log;

Установка EventEmitter.captureRejections = true изменит значение по умолчанию для всех новых экземпляров EventEmitter.

EventEmitter.captureRejections = true;
const ee1 = new EventEmitter();
ee1.on('something', async (value) => {
  throw new Error('kaboom');
});

ee1.on('error', console.log);

События 'error' , которые генерируются поведением captureRejections , не имеют обработчика catch, чтобы избежать бесконечных циклов ошибок: рекомендуется не использовать async функции в качестве 'error' обработчиков событий.

Класс: `EventEmitter`

История

Версия	Изменения
v12.16.0	Добавлена опция captureRejections.
v0.1.26	Добавлена в: v0.1.26

Класс EventEmitter определен и экспортируется модулем events:

const EventEmitter = require('events');

Все экземпляры EventEmitter излучают событие 'newListener' при добавлении новых слушателей и 'removeListener' при удалении существующих слушателей.

Поддерживает следующие опции:

captureRejections <boolean> Включает автоматический захват отказов обещаний. Значение по умолчанию: false.

Событие: 'newListener'

Добавлена в: v0.1.26

eventName <строка> | <символ> Имя события, на которое подписываются
listener <Функция> Функция-обработчик события

Экземпляр EventEmitter излучит собственное событие 'newListener' до добавления слушателя в его внутренний массив слушателей.

Слушатели, зарегистрированные для события 'newListener' , получат имя события и ссылку на добавляемого слушателя.

Тот факт, что событие запускается перед добавлением слушателя, имеет тонкий, но важный побочный эффект: любые дополнительные слушатели, зарегистрированные для того же name внутри коллбэка 'newListener' , будут вставлены перед слушателем, который в процессе добавления.

const myEmitter = new MyEmitter();
// Only do this once so we don't loop forever
myEmitter.once('newListener', (event, listener) => {
  if (event === 'event') {
    // Insert a new listener in front
    myEmitter.on('event', () => {
      console.log('B');
    });
  }
});
myEmitter.on('event', () => {
  console.log('A');
});
myEmitter.emit('event');
// Prints:
//   B
//   A

Событие: `'removeListener'`

История

Версия	Изменения
v6.1.0, v4.7.0	Для слушателей, прикрепленных с помощью `.once()`, аргумент `listener` теперь возвращает исходную функцию-слушатель.
v0.9.3	Добавлена в: v0.9.3

eventName <строка> | <символ> Имя события
listener <Функция> Функция-обработчик события

Событие 'removeListener' излучается после удаления listener.

`EventEmitter.listenerCount(emitter, eventName)`

Добавлена в: v0.9.12Устарела начиная с: v3.2.0

Устойчивость: 0 - Устарело: Используйте emitter.listenerCount() вместо этого.

emitter <EventEmitter> Эмиттер для запроса
eventName <строка> | <символ> Имя события

Метод класса, возвращающий количество слушателей для данного eventName , зарегистрированных на указанном emitter.

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

`EventEmitter.defaultMaxListeners`

Добавлена в: v0.11.2

По умолчанию максимальное количество слушателей, которые могут быть зарегистрированы для любого отдельного события, равно 10 . Этот лимит можно изменить для отдельных экземпляров EventEmitter с помощью метода emitter.setMaxListeners(n). Чтобы изменить значение по умолчанию для всех экземпляров EventEmitter , можно использовать свойство EventEmitter.defaultMaxListeners . Если это значение не является положительным числом, будет выброшено TypeError.

Будьте осторожны при установке EventEmitter.defaultMaxListeners , потому что изменение затрагивает все экземпляры EventEmitter , включая те, которые были созданы до внесения изменения. Однако вызов emitter.setMaxListeners(n) имеет приоритет над EventEmitter.defaultMaxListeners.

Это не жёсткое ограничение. Экземпляр EventEmitter позволит добавить больше слушателей, но выведет предупреждение в stderr, указывающее, что обнаружена "возможная утечка памяти EventEmitter". Для любого отдельного EventEmitter, методы emitter.getMaxListeners() и emitter.setMaxListeners() могут быть использованы для временного избежания этого предупреждения:

emitter.setMaxListeners(emitter.getMaxListeners() + 1);
emitter.once('event', () => {
  // do stuff
  emitter.setMaxListeners(Math.max(emitter.getMaxListeners() - 1, 0));
});

Флаг командной строки --trace-warnings может использоваться для отображения стека вызовов таких предупреждений.

Выведенное предупреждение можно просмотреть с помощью process.on('warning') и оно будет иметь дополнительные свойства emitter, type и count, которые ссылаются соответственно на экземпляр эмиттера событий, имя события и количество прикрепленных слушателей. Его свойство name установлено в 'MaxListenersExceededWarning'.

`EventEmitter.errorMonitor`

Добавлена в: v12.17.0

Этот символ используется для установки слушателя, который будет следить только за событиями 'error'. Слушатели, установленные с помощью этого символа, вызываются до вызова обычных слушателей 'error'.

Установка слушателя с помощью этого символа не меняет поведение после того, как событие 'error' было излучено, поэтому процесс всё ещё аварийно завершится, если не установлен обычный слушатель 'error'.

`emitter.addListener(eventName, listener)`

Добавлен в: v0.1.26

eventName <строка> | <символ>
listener <Функция>

Псевдоним для emitter.on(eventName, listener).

`emitter.emit(eventName[, ...args])`

Добавлен в: v0.1.26

Синхронно вызывает каждый из слушателей, зарегистрированных для события с именем eventName, в порядке их регистрации, передавая предоставленные аргументы каждому из них.

Возвращает true, если у события были слушатели, false в противном случае.

const EventEmitter = require('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

`emitter.eventNames()`

Добавлен в: v6.0.0

Возвращает: <Массив>

Возвращает массив, перечисляющий события, для которых эмиттер зарегистрировал слушателей. Значения в массиве будут строками или Symbol.

const EventEmitter = require('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) ]

`emitter.getMaxListeners()`

Добавлен в: v1.0.0

Возвращает: <целое число>

Возвращает текущее максимальное значение слушателей для EventEmitter, которое устанавливается с помощью emitter.setMaxListeners(n) или по умолчанию равно EventEmitter.defaultMaxListeners.

`emitter.listenerCount(eventName)`

Добавлен в: v3.2.0

eventName <строка> | <символ> Имя события, за которым следят.
Возвращает: <целое число>

Возвращает количество слушателей, которые следят за событием с именем eventName.

`emitter.listeners(eventName)`

История изменений

Версия	Изменения
v7.0.0	Для слушателей, прикрепленных с помощью `.once()`, теперь возвращаются исходные слушатели, а не обертки функций.
v0.1.26	Добавлен в: v0.1.26

eventName <строка> | <символ>
Возвращает: <Массив функций>

Возвращает копию массива слушателей для события с именем eventName.

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

`emitter.off(eventName, listener)`

Добавлен в: v10.0.0

eventName <строка> | <символ>
listener <Функция>
Возвращает: <EventEmitter>

Псевдоним для emitter.removeListener().

`emitter.on(eventName, listener)`

Добавлен в: v0.1.101

eventName <строка> | <символ> Название события.
listener <Функция> Функция обратного вызова.
Возвращает: <EventEmitter>

Добавляет функцию обратного вызова listener в конец массива слушателей для события с именем eventName. Проверки того, что функция обратного вызова уже добавлена, не выполняется. Несколько вызовов с одинаковой комбинацией eventName и listener приведут к добавлению и вызову функции обратного вызова listener несколько раз.

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

Возвращает ссылку на EventEmitter, чтобы можно было объединять вызовы.

По умолчанию слушатели событий вызываются в порядке их добавления. Метод emitter.prependListener() может быть использован как альтернатива для добавления слушателя события в начало массива слушателей.

const myEE = new EventEmitter();
myEE.on('foo', () => console.log('a'));
myEE.prependListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

`emitter.once(eventName, listener)`

Добавлен в: v0.3.0

eventName <строка> | <символ> Название события.
listener <Функция> Функция обратного вызова.
Возвращает: <EventEmitter>

Добавляет одноразовую функцию обратного вызова listener для события с именем eventName. В следующий раз, когда будет срабатывать eventName, этот слушатель будет удалён, а затем вызван.

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

Возвращает ссылку на EventEmitter, чтобы можно было объединять вызовы.

По умолчанию слушатели событий вызываются в порядке их добавления. Метод emitter.prependOnceListener() может быть использован как альтернатива для добавления слушателя события в начало массива слушателей.

const myEE = new EventEmitter();
myEE.once('foo', () => console.log('a'));
myEE.prependOnceListener('foo', () => console.log('b'));
myEE.emit('foo');
// Prints:
//   b
//   a

`emitter.prependListener(eventName, listener)`

Добавлен в: v6.0.0

eventName <строка> | <символ> Название события.
listener <Функция> Функция обратного вызова.
Возвращает: <EventEmitter>

Добавляет функцию обратного вызова listener в начало массива слушателей для события с именем eventName. Проверки того, что функция обратного вызова уже добавлена, не выполняется. Несколько вызовов с одинаковой комбинацией eventName и listener приведут к добавлению и вызову функции обратного вызова listener несколько раз.

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

Возвращает ссылку на EventEmitter, чтобы можно было объединять вызовы.

`emitter.prependOnceListener(eventName, listener)`

Добавлен в: v6.0.0

eventName <строка> | <символ> Название события.
listener <Функция> Функция обратного вызова.
Возвращает: <EventEmitter>

Добавляет одноразовую функцию обратного вызова listener для события с именем eventName в начало массива слушателей. В следующий раз, когда будет срабатывать eventName, этот слушатель будет удалён, а затем вызван.

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

Возвращает ссылку на EventEmitter, чтобы можно было объединять вызовы.

`emitter.removeAllListeners([eventName])`

Добавлен в: v0.1.26

eventName <строка> | <символ>
Возвращает: <EventEmitter>

Удаляет всех слушателей или тех, которые относятся к указанному eventName.

Не рекомендуется удалять слушателей, добавленных в другом месте кода, особенно когда экземпляр EventEmitter был создан другим компонентом или модулем (например, сокетами или потоками файлов).

Возвращает ссылку на EventEmitter, чтобы можно было объединять вызовы.

`emitter.removeListener(eventName, listener)`

Добавлен в: v0.1.26

eventName <строка> | <символ>
listener <Функция>
Возвращает: <EventEmitter>

Удаляет указанный listener из массива слушателей для события с именем eventName.

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

removeListener() удалит, как максимум, один экземпляр слушателя из массива слушателей. Если какой-либо отдельный слушатель был добавлен несколько раз в массив слушателей для указанного eventName, то removeListener() необходимо вызвать несколько раз, чтобы удалить каждый экземпляр.

После того, как событие было выпущено, все слушатели, прикрепленные к нему в момент выпуска, будут вызваны в порядке. Это означает, что любые removeListener() или removeAllListeners() вызовы после выпуска и до завершения выполнения последнего слушателя не удалят их из emit() в процессе. Последующие события будут работать как ожидается.

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

Поскольку слушатели управляются с помощью внутреннего массива, вызов этого изменит индексы позиций любого слушателя, зарегистрированного после удаляемого слушателя. Это не повлияет на порядок вызова слушателей, но это означает, что любые копии массива слушателей, возвращаемые методом emitter.listeners(), потребуют пересоздания.

Когда одна функция была добавлена в качестве обработчика несколько раз для одного события (как в примере ниже), removeListener() удалит последний добавленный экземпляр. В примере удаляется слушатель once('ping').

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

Возвращает ссылку на EventEmitter, чтобы вызовы можно было объединять.

`emitter.setMaxListeners(n)`

Добавлен в: v0.3.5

n <целое число>
Возвращает: <EventEmitter>

По умолчанию EventEmitter будут выводить предупреждение, если для определенного события будет добавлено более 10 слушателей. Это полезный стандартный вариант, который помогает найти утечки памяти. Метод emitter.setMaxListeners() позволяет изменить предел для этого конкретного экземпляра EventEmitter. Значение можно установить на Infinity (или 0) для указания неограниченного количества слушателей.

Возвращает ссылку на EventEmitter, чтобы вызовы можно было объединять.

`emitter.rawListeners(eventName)`

Добавлен в: v9.4.0

eventName <строка> | <символ>
Возвращает: <Функция[]>

Возвращает копию массива слушателей для события с именем eventName, включая любые оболочки (такие, как созданные .once()).

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

`emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])`

Добавлен в: v12.16.0

Стабильность: 1 - captureRejections экспериментальная.

err Ошибка
eventName <строка> | <символ>
...args <любой>

Метод Symbol.for('nodejs.rejection') вызывается в случае отклонения обещания при выводе события и captureRejections включен для эмиттера. Возможна замена Symbol.for('nodejs.rejection') на events.captureRejectionSymbol.

const { EventEmitter, captureRejectionSymbol } = require('events');

class MyClass extends EventEmitter {
  constructor() {
    super({ captureRejections: true });
  }

  [captureRejectionSymbol](err, event, ...args) {
    console.log('rejection happened for', event, 'with', err, ...args);
    this.destroy(err);
  }

  destroy(err) {
    // Tear the resource down here.
  }
}

`events.once(emitter, name)`

Добавлен в: v11.13.0

emitter <EventEmitter>
name <строка>
Возвращает: <Обещание>

Создаёт Promise, которое выполняется, когда EventEmitter выпускает заданное событие, или которое отклоняется, если EventEmitter выпускает 'error' в ожидании. Promise будет разрешено массивом всех аргументов, выпущенных для заданного события.

Этот метод преднамеренно универсален и работает с интерфейсом EventTarget веб-платформы, который не имеет специальных семантик событий 'error' и не прослушивает событие 'error'.

const { once, EventEmitter } = require('events');

async function run() {
  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.log('error happened', err);
  }
}

run();

Специальная обработка события 'error' используется только тогда, когда events.once() используется для ожидания другого события. Если events.once() используется для ожидания события 'error'', то оно обрабатывается как любое другое событие без специальной обработки.

const { EventEmitter, once } = require('events');

const ee = new EventEmitter();

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

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

// Prints: ok boom

Ожидание нескольких событий, выпущенных на `process.nextTick()`

Есть крайний случай, который стоит отметить, когда используется функция events.once() для ожидания нескольких событий, выпущенных на в той же партии операций process.nextTick(), или когда несколько событий выпускаются синхронно. В частности, так как очередь process.nextTick() опорожняется перед очереди микрозадач Promise, и так как EventEmitter выпускает все события синхронно, возможно, что events.once() пропустит событие.

const { EventEmitter, once } = require('events');

const myEE = new EventEmitter();

async function foo() {
  await once(myEE, 'bar');
  console.log('bar');

  // This Promise will never resolve because the 'foo' event will
  // have already been emitted before the Promise is created.
  await once(myEE, 'foo');
  console.log('foo');
}

process.nextTick(() => {
  myEE.emit('bar');
  myEE.emit('foo');
});

foo().then(() => console.log('done'));

Чтобы поймать оба события, создайте каждое из обещаний до ожидания любого из них, затем можно использовать Promise.all(), Promise.race(), или Promise.allSettled().

const { EventEmitter, once } = require('events');

const myEE = new EventEmitter();

async function foo() {
  await Promise.all([once(myEE, 'bar'), once(myEE, 'foo')]);
  console.log('foo', 'bar');
}

process.nextTick(() => {
  myEE.emit('bar');
  myEE.emit('foo');
});

foo().then(() => console.log('done'));

`events.captureRejections`

Добавлен в: v12.16.0

Стабильность: 1 - captureRejections экспериментальная.

Значение: <логическое>

Измените опцию captureRejections по умолчанию для всех новых объектов EventEmitter.

events.captureRejectionSymbol

Добавлен в: v12.16.0

Стабильность: 1 - captureRejections экспериментальная.

Значение: Symbol.for('nodejs.rejection')

Узнайте, как написать пользовательскую обработчик отклонений.

events.on(emitter, eventName)[src]

Добавлен в: v12.16.0

emitter <EventEmitter>
eventName <строка> | <символ> Имя события, на которое подписываются
Возвращает: <ИтераторAsync> для итерации eventName событий, испускаемых emitter

const { on, EventEmitter } = require('events');

(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')) {
    // 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
})();

Возвращает AsyncIterator, который итерирует eventName события. Он будет выбрасывать исключение, если EventEmitter выпустит 'error'. Все слушатели удаляются при выходе из цикла. value возвращаемое каждой итерацией, является массивом аргументов события, выпущенного.

© Joyent, Inc. and other Node contributors
Licensed under the MIT License.
Node.js is a trademark of Joyent, Inc. and is used with its permission.
We are not endorsed by or affiliated with Joyent.
https://nodejs.org/dist/latest-v12.x/docs/api/events.html

События

Передача аргументов и this слушателям

Асинхронный и синхронный режимы

Обработка событий только один раз

События ошибок

Перехват отказов обещаний

Класс: EventEmitter

Событие: 'newListener'

Событие: 'removeListener'

EventEmitter.listenerCount(emitter, eventName)

EventEmitter.defaultMaxListeners

EventEmitter.errorMonitor

emitter.addListener(eventName, listener)

emitter.emit(eventName[, ...args])

emitter.eventNames()

emitter.getMaxListeners()

emitter.listenerCount(eventName)

emitter.listeners(eventName)

emitter.off(eventName, listener)

emitter.on(eventName, listener)

emitter.once(eventName, listener)

emitter.prependListener(eventName, listener)

emitter.prependOnceListener(eventName, listener)

emitter.removeAllListeners([eventName])

emitter.removeListener(eventName, listener)

emitter.setMaxListeners(n)

emitter.rawListeners(eventName)

emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])

events.once(emitter, name)

Ожидание нескольких событий, выпущенных на process.nextTick()

events.captureRejections

events.captureRejectionSymbol

events.on(emitter, eventName)[src]

Передача аргументов и `this` слушателям

Класс: `EventEmitter`

Событие: `'removeListener'`

`EventEmitter.listenerCount(emitter, eventName)`

`EventEmitter.defaultMaxListeners`

`EventEmitter.errorMonitor`

`emitter.addListener(eventName, listener)`

`emitter.emit(eventName[, ...args])`

`emitter.eventNames()`

`emitter.getMaxListeners()`

`emitter.listenerCount(eventName)`

`emitter.listeners(eventName)`

`emitter.off(eventName, listener)`

`emitter.on(eventName, listener)`

`emitter.once(eventName, listener)`

`emitter.prependListener(eventName, listener)`

`emitter.prependOnceListener(eventName, listener)`

`emitter.removeAllListeners([eventName])`

`emitter.removeListener(eventName, listener)`

`emitter.setMaxListeners(n)`

`emitter.rawListeners(eventName)`

`emitter[Symbol.for('nodejs.rejection')](err, eventName[, ...args])`

`events.once(emitter, name)`

Ожидание нескольких событий, выпущенных на `process.nextTick()`

`events.captureRejections`