emitter.removeListener(eventName, listener)

• eventName <string> | <symbol>
• listener <Function>
• 返回：<EventEmitter>

从名为 eventName 的事件的监听器数组中移除指定的 listener。

🌐 Removes the specified listener from the listener array for the event named eventName.

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

removeListener() 最多会从监听器数组中移除一个监听器实例。如果同一个监听器已被多次添加到指定 eventName 的监听器数组中，则必须多次调用 removeListener() 才能移除每一个实例。

一旦事件被触发，当时附加到该事件的所有监听器都会按顺序被调用。这意味着在事件触发之后、最后一个监听器完成执行之前的任何 removeListener() 或 removeAllListeners() 调用，都不会将它们从正在进行的 emit() 中移除。随后的事件行为则如预期一样。

🌐 Once an event is emitted, all listeners attached to it at the time of emitting are called in order. This implies that any removeListener() or removeAllListeners() calls after emitting and before the last listener finishes execution will not remove them from emit() in progress. Subsequent events behave as expected.

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:
//   Aconst EventEmitter = require('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拷贝

由于监听器是通过内部数组管理的，调用此方法会更改在被移除的监听器之后注册的任何监听器的位置索引。这不会影响监听器被调用的顺序，但这意味着通过 emitter.listeners() 方法返回的监听器数组的任何副本都需要重新创建。

🌐 Because listeners are managed using an internal array, calling this will change the position indexes of any listener registered after the listener being removed. This will not impact the order in which listeners are called, but it means that any copies of the listener array as returned by the emitter.listeners() method will need to be recreated.

当一个函数被多次添加为单个事件的处理程序时（如下面的示例所示），removeListener() 会移除最近添加的实例。在示例中，once('ping') 监听器被移除：

🌐 When a single function has been added as a handler multiple times for a single event (as in the example below), removeListener() will remove the most recently added instance. In the example the once('ping') listener is removed:

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');const EventEmitter = require('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');拷贝

返回 EventEmitter 的引用，以便可以进行链式调用。

🌐 Returns a reference to the EventEmitter, so that calls can be chained.