Class TypedEventEmitter<Events>

A class method that returns the number of listeners for the given eventNameregistered on the given emitter.一个类方法，用于返回在给定emitter上注册的给定eventName的侦听器数。

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

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

Since

v0.9.12

Deprecated

Since v3.2.0 - Use listenerCount instead.

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此处无法访问
Copy

Returns an AsyncIterator that iterates eventName events. 返回一个迭代eventName事件的AsyncIterator。It will throw if the EventEmitter emits 'error'. 如果EventEmitter发出'error'，它将抛出。It removes all listeners when exiting the loop. 它在退出循环时删除所有侦听器。The value returned by each iteration is an array composed of the emitted event arguments.每次迭代返回的value是一个由发出的事件参数组成的数组。

An AbortSignal can be used to cancel waiting on events:AbortSignal可用于取消等待事件：

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

Since

v13.6.0, v12.16.0

Creates a Promise that is fulfilled when the EventEmitter emits the given event or that is rejected if the EventEmitter emits 'error' while waiting.创建一个Promise，该Promise在EventEmitter发出给定事件时实现，或者如果EventEmitter在等待时发出'error'则被拒绝。 The Promise will resolve with an array of all the arguments emitted to the given event.Promise将通过向给定事件发出的所有参数的数组进行解析。

This method is intentionally generic and works with the web platform EventTarget interface, which has no special'error' event semantics and does not listen to the 'error' event.此方法是有意通用的，可与web平台EventTarget接口配合使用，该接口没有特殊的'error'事件语义，也不侦听'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);
}
Copy

The special handling of the 'error' event is only used when events.once()is used to wait for another event. 'error'事件的特殊处理仅在events.once()用于等待另一个事件时使用。If events.once() is used to wait for the 'error' event itself, then it is treated as any other kind of event without special handling:如果events.once()用于等待'error'事件本身，那么它将被视为任何其他类型的事件，而无需特殊处理：

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
Copy

An AbortSignal can be used to cancel waiting for the event:AbortSignal可用于取消等待事件：

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!打印：等待活动已取消！
Copy

Since

v11.13.0, v10.16.0

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

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

setMaxListeners(5, target, emitter);
Copy

Since

v15.4.0