如何在继承事件冒泡前捕获并阻止？Node.js Socket扩展场景

嘿，我刚好折腾过类似的Node.js Socket继承场景，针对你想要阻止父类事件冒泡、自定义触发事件的需求，这里有几个ES2015+的可行思路，亲测好用：

方案一：重写emit方法拦截事件流 #

Socket类继承自EventEmitter，所以我们可以直接重写核心的emit方法，从事件发射的源头拦截父类事件，转而触发自定义逻辑。这是最直接、可控性最强的方案。

import { Socket } from 'net';

class CustomTCPSocket extends Socket {
  constructor(options) {
    super(options);
    // 定义需要拦截的父类事件列表
    this.blockedEvents = ['data', 'connect', 'error'];
  }

  emit(eventName, ...args) {
    // 检查当前事件是否在拦截名单中
    if (this.blockedEvents.includes(eventName)) {
      // 执行自定义逻辑，触发专属事件
      switch(eventName) {
        case 'data':
          // 对原始数据做TCP/IP封装处理
          const encapsulatedData = this.wrapWithProtocol(args[0]);
          super.emit('customData', encapsulatedData);
          break;
        case 'connect':
          super.emit('customConnect');
          break;
        case 'error':
          // 可以自定义错误格式后触发
          const formattedError = new Error(`Protocol Error: ${args[0].message}`);
          super.emit('customError', formattedError);
          break;
      }
      // 返回true标记事件已处理，阻止父类默认行为
      return true;
    }
    // 非拦截事件，调用父类原生emit方法
    return super.emit(eventName, ...args);
  }

  // 自定义的TCP/IP封装逻辑
  wrapWithProtocol(rawData) {
    // 这里实现你的协议封装规则，比如添加头部、校验位等
    const protocolHeader = Buffer.from('MY_PROTOCOL_V1');
    return Buffer.concat([protocolHeader, rawData]);
  }
}

优点：逻辑集中在emit方法，完全掌控事件流向，容易扩展拦截的事件类型，彻底阻止父类事件冒泡。

方案二：移除父类默认监听器，绑定自定义逻辑 #

如果只需要替换个别事件的行为，不需要全局拦截所有事件，可以在子类构造函数中移除父类的默认监听器，再绑定自己的处理逻辑，触发自定义事件。

import { Socket } from 'net';

class CustomTCPSocket extends Socket {
  constructor(options) {
    super(options);
    
    // 移除父类默认的事件监听器
    this.removeAllListeners('data');
    this.removeAllListeners('connect');

    // 绑定自定义的事件处理逻辑
    super.on('data', (rawData) => {
      const encapsulatedData = this.wrapWithProtocol(rawData);
      this.emit('customData', encapsulatedData);
    });

    super.on('connect', () => {
      // 可以添加自定义的连接初始化逻辑
      this.initProtocol();
      this.emit('customConnect');
    });
  }

  wrapWithProtocol(rawData) {
    const protocolHeader = Buffer.from('MY_PROTOCOL_V1');
    return Buffer.concat([protocolHeader, rawData]);
  }

  initProtocol() {
    // 比如发送协议握手包
    this.write(Buffer.from('PROTOCOL_HANDSHAKE'));
  }
}

适用场景：只需要修改特定几个事件的行为，不想全局修改emit方法的场景。注意部分内部事件可能无法完全移除，需要实际测试验证。

方案三：拦截监听器绑定，兼容外部调用逻辑 #

如果希望外部代码可以像使用原生Socket一样绑定事件（比如还是用data而不是customData），但实际收到的是封装后的数据，可以通过拦截newListener事件来替换监听器。

import { Socket } from 'net';

class CustomTCPSocket extends Socket {
  constructor(options) {
    super(options);
    
    // 监听监听器绑定事件
    this.on('newListener', (eventName, listener) => {
      if (eventName === 'data') {
        // 移除刚绑定的原生data监听器
        this.removeListener(eventName, listener);
        // 替换为监听自定义事件，传入封装后的数据
        this.on('customData', (encapsulatedData) => {
          listener(encapsulatedData);
        });
      }
    });

    // 内部处理原生data事件，触发自定义事件
    super.on('data', (rawData) => {
      this.emit('customData', this.wrapWithProtocol(rawData));
    });
  }

  wrapWithProtocol(rawData) {
    const protocolHeader = Buffer.from('MY_PROTOCOL_V1');
    return Buffer.concat([protocolHeader, rawData]);
  }
}

适用场景：需要兼容原有代码，不需要调用方修改事件名称的场景，对外保持原生Socket的事件接口，但内部做协议封装。

总结 #

如果想要完全掌控所有事件的发射逻辑，方案一是最优选择，它直接从事件发射的入口拦截，彻底阻止父类事件冒泡，同时灵活处理自定义事件。要是只需要替换少数几个事件的行为，方案二更简单直接。方案三则适合需要兼容外部原有代码、不需要调用方修改事件名称的场景。

内容的提问来源于stack exchange，提问作者canaan seaton