如何用JavaScript实现一个支持多播的事件发射器？

class EventEmitter {
    constructor() {
        // 使用Map来存储事件，键是事件名（字符串），值是一个数组，里面存放着所有订阅该事件的回调函数。
        // Map的好处是键可以是任意类型，虽然这里我们主要用字符串，但它在处理非字符串键时更灵活。
        this.events = new Map();
    }

    /**
     * 注册一个事件监听器。
     * @param {string} eventName - 事件的名称。
     * @param {Function} listener - 当事件触发时执行的回调函数。
     * @returns {EventEmitter} - 返回EventEmitter实例，支持链式调用。
     */
    on(eventName, listener) {
        // 如果这个事件名还没被注册过，就初始化一个空数组。
        if (!this.events.has(eventName)) {
            this.events.set(eventName, []);
        }
        // 把新的监听器添加到对应事件名的数组中。
        // 这里我选择允许同一个listener被多次添加，因为在某些场景下，你可能确实需要同一个函数实例在不同上下文或参数下多次绑定。
        // 如果你希望避免重复添加，可以在这里加一个检查：!this.events.get(eventName).includes(listener)
        this.events.get(eventName).push(listener);
        return this; // 方便进行链式调用，比如 myEmitter.on('foo', fn1).on('bar', fn2);
    }

    /**
     * 移除一个事件监听器。
     * @param {string} eventName - 事件的名称。
     * @param {Function} listener - 要移除的回调函数。
     * @returns {EventEmitter} - 返回EventEmitter实例。
     */
    off(eventName, listener) {
        // 如果事件名不存在，或者没有对应的监听器，就直接返回。
        if (!this.events.has(eventName)) {
            return this;
        }

        const listeners = this.events.get(eventName);
        // 找到要移除的监听器在数组中的索引。
        const index = listeners.indexOf(listener);

        if (index > -1) {
            // 使用splice移除该监听器。
            listeners.splice(index, 1);
        }

        // 如果某个事件的所有监听器都被移除了，清理掉这个事件名，保持Map的整洁，避免内存中残留空数组。
        if (listeners.length === 0) {
            this.events.delete(eventName);
        }
        return this;
    }

    /**
     * 触发一个事件，并向所有注册的监听器传递参数。
     * @param {string} eventName - 要触发的事件名称。
     * @param {...any} args - 传递给监听器的参数。
     * @returns {boolean} - 如果有监听器被触发，返回true；否则返回false。
     */
    emit(eventName, ...args) {
        // 如果这个事件名没有对应的监听器，就没必要继续了。
        if (!this.events.has(eventName)) {
            return false;
        }

        // 这里有个小技巧：我们对监听器数组进行浅拷贝。
        // 这样做是为了防止在事件触发过程中，某个监听器内部又调用了 `off` 方法移除了其他监听器，
        // 从而影响了当前正在进行的迭代，导致一些意想不到的行为。
        const listeners = [...this.events.get(eventName)];

        listeners.forEach(listener => {
            try {
                // 调用监听器，并把EventEmitter实例作为上下文（this）。
                // 这样，在监听器内部，如果需要访问EventEmitter的其他方法，就可以通过this来获取。
                listener.apply(this, args);
            } catch (error) {
                // 实际应用中，这里可能需要更复杂的错误处理机制。
                // 比如，可以触发一个特殊的 'error' 事件，让专门的错误处理器来处理。
                // 否则，一个监听器中的错误可能会中断其他监听器的执行（取决于错误类型和环境）。
                console.error(`Error in listener for event "${eventName}":`, error);
                // 这里捕获错误后，会继续执行下一个监听器，确保一个监听器的失败不会影响所有其他监听器。
            }
        });
        return true;
    }

    /**
     * 注册一个只触发一次的事件监听器。事件触发后，该监听器会自动被移除。
     * @param {string} eventName - 事件的名称。
     * @param {Function} listener - 当事件触发时执行的回调函数。
     * @returns {EventEmitter} - 返回EventEmitter实例。
     */
    once(eventName, listener) {
        // 创建一个包装函数，它会在执行原始listener后，自动调用off方法移除自己。
        const onceWrapper = (...args) => {
            listener.apply(this, args);
            this.off(eventName, onceWrapper); // 关键一步：触发后移除自身
        };
        // 为了能正确地移除这个onceWrapper，我们需要把它添加到事件列表中。
        // 如果原始listener有特殊标识，也可以考虑把标识传给onceWrapper，以便更精确地移除。
        this.on(eventName, onceWrapper);
        return this;
    }

    /**
     * 返回指定事件的监听器数量。
     * @param {string} eventName - 事件名称。
     * @returns {number} - 监听器数量。
     */
    listenerCount(eventName) {
        return this.events.has(eventName) ? this.events.get(eventName).length : 0;
    }

    /**
     * 移除所有监听器，或者移除指定事件的所有监听器。
     * @param {string} [eventName] - 可选。如果提供，则移除该事件的所有监听器；否则移除所有事件的所有监听器。
     * @returns {EventEmitter} - 返回EventEmitter实例。
     */
    removeAllListeners(eventName) {
        if (eventName) {
            this.events.delete(eventName);
        } else {
            this.events.clear(); // 清空所有事件
        }
        return this;
    }
}

// 示例用法：
const myBus = new EventEmitter();

function handlerA(data) {
    console.log('Handler A received:', data);
}

function handlerB(data) {
    console.log('Handler B processed:', data);
}

function handlerC(data) {
    console.log('Handler C logged:', data);
}

// 注册多个监听器到同一个事件
myBus.on('dataReady', handlerA);
myBus.on('dataReady', handlerB);
myBus.on('dataReady', handlerC);

myBus.emit('dataReady', { id: 1, value: 'initial' });
// 输出：
// Handler A received: { id: 1, value: 'initial' }
// Handler B processed: { id: 1, value: 'initial' }
// Handler C logged: { id: 1, value: 'initial' }

myBus.off('dataReady', handlerB); // 移除其中一个监听器

myBus.emit('dataReady', { id: 2, value: 'updated' });
// 输出：
// Handler A received: { id: 2, value: 'updated' }
// Handler C logged: { id: 2, value: 'updated' } (handlerB 不再响应)

myBus.once('singleUseEvent', (msg) => {
    console.log('This will only run once:', msg);
});

myBus.emit('singleUseEvent', 'first call'); // 触发
myBus.emit('singleUseEvent', 'second call'); // 不会再触发

// 错误处理演示
myBus.on('errorProne', () => {
    console.log('About to throw error...');
    throw new Error('Something went wrong in this specific listener!');
});
myBus.on('errorProne', () => {
    console.log('This listener still runs even if previous one failed.');
});
myBus.emit('errorProne');
// 输出：
// About to throw error...
// Error in listener for event "errorProne": Error: Something went wrong in this specific listener!
// This listener still runs even if previous one failed.