TypeScript技巧：强制子类重写方法时调用父类super方法

这个需求挺常见的，在TypeScript里确实有几种实用的技巧来实现，我给你拆解一下：

方案一：编译时强制约束（通过返回值标记） #

这个方法能让TypeScript在编译阶段就报错，直接阻止不符合要求的代码上线。核心思路是给基类的foo()方法返回一个唯一的符号，要求子类必须返回这个符号（只能通过调用super.foo()获取）：

// 定义一个唯一的符号，用来标记super.foo()是否被调用
const SUPER_FOO_INVOKED = Symbol('super-foo-invoked');

export class BaseComponent {
  foo(): typeof SUPER_FOO_INVOKED {
    return SUPER_FOO_INVOKED;
  }
}

export class ExtendedComponent extends BaseComponent {
  constructor() { super(); }

  // ❌ 编译错误：返回值类型不匹配，必须返回SUPER_FOO_INVOKED
  foo() {
    // 子类逻辑
    return; 
  }

  // ✅ 正确写法：必须调用super.foo()并返回其结果
  foo() {
    const superResult = super.foo();
    // 这里写子类自己的逻辑
    return superResult;
  }
}

优点：编译阶段就能发现问题，不需要运行时检查；缺点：如果你的foo()原本有返回值，需要调整返回类型（比如可以把符号作为返回值的一部分，比如返回[SUPER_FOO_INVOKED, yourReturnValue]）。

方案二：运行时兜底检查（装饰器） #

如果不想修改基类的返回值，可以用装饰器在运行时检查子类是否调用了super.foo()，适合需要兼容原有代码的场景。首先要在tsconfig.json里启用装饰器支持："experimentalDecorators": true。

实现代码如下：

function enforceSuperCall(target: any, methodName: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  
  descriptor.value = function(...args: any[]) {
    let superWasCalled = false;
    // 临时替换父类的方法，标记是否被调用
    const parentPrototype = Object.getPrototypeOf(target);
    const originalSuperMethod = parentPrototype[methodName];
    
    parentPrototype[methodName] = function() {
      superWasCalled = true;
      return originalSuperMethod.apply(this, args);
    };
    
    // 执行子类的方法
    const result = originalMethod.apply(this, args);
    
    // 恢复父类的原方法
    parentPrototype[methodName] = originalSuperMethod;
    
    // 检查是否调用了super
    if (!superWasCalled) {
      throw new Error(`错误：${this.constructor.name}的${methodName}方法必须调用super.${methodName}()`);
    }
    
    return result;
  };
}

export class BaseComponent {
  foo() {
    // 基类的逻辑
  }
}

export class ExtendedComponent extends BaseComponent {
  constructor() { super(); }

  // ❌ 运行时会抛出错误：没调用super.foo()
  // @enforceSuperCall
  // foo() { }

  // ✅ 正确写法：运行时正常执行
  @enforceSuperCall
  foo() {
    super.foo();
    // 子类逻辑
  }
}

优点：不需要修改基类的原有实现；缺点：只能在运行时发现问题，编译阶段不会报错。

方案三：双重保障（编译+运行时结合） #

如果想要最大程度避免问题，可以把上面两个方案结合起来：编译时用返回值约束提前拦截错误，运行时用装饰器兜底防止意外情况，既在开发阶段提效，又在生产环境增加安全保障。

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