TypeScript中带类型限制的继承实现难题

问题概述 #

需要创建高层抽象类Unit，包含子类共享逻辑；每个子类的act方法返回专属类型，顶层抽象类定义act的动态接口，但子类需严格限制返回自身专属类型，避免重复声明抽象方法，同时解决TS类型不兼容问题。

解决方案 #

通过泛型约束抽象类，将Unit类与具体的动作类型绑定，让子类自动继承对应的返回类型约束，无需重复声明抽象方法，同时保证TS的类型严格检查。修改后的实现如下：

修改后的代码示例 #

enum UnitActions {
  run = 'run',
  fly = 'fly',
  dive = 'dive',
}

type UnitRunResult = { distance: number; time: number };
type UnitFlyResult = { distance: number; vector: { x: number; y: number } };
type UnitSwimResult = { distance: number; depth: number };

type UnitActionResults<T extends UnitActions> = 
  T extends UnitActions.run ? UnitRunResult :
  T extends UnitActions.fly ? UnitFlyResult :
  T extends UnitActions.dive ? UnitSwimResult :
  never;

// 泛型抽象类，绑定动作类型与返回结果
abstract class Unit<T extends UnitActions> {
  public abstract actionType: T;
  public abstract act(): UnitActionResults<T>;
}

// 抽象子类直接指定泛型参数，自动继承返回类型约束
abstract class WoodenUnit extends Unit<UnitActions.run> {
  public actionType = UnitActions.run;
  // 无需重复声明act的抽象方法，TS自动约束返回UnitRunResult
}

class Pinokio extends WoodenUnit {
  public act() {
    return { distance: 20, time: 3 }; // TS自动检查是否符合UnitRunResult
  }
}

// 高层函数利用类型关联性自动推断结果类型
function test<T extends UnitActions>(unit: Unit<T>) {
  switch (unit.actionType) {
    case UnitActions.run: {
      const result = unit.act(); // result类型为UnitRunResult
      console.log(result.time); // TS能正确提示属性
      return;
    }
    case UnitActions.fly: {
      const result = unit.act(); // result类型为UnitFlyResult
      console.log(result.vector);
      return;
    }
    case UnitActions.dive: {
      const result = unit.act(); // result类型为UnitSwimResult
      console.log(result.depth);
      return;
    }
  }
}

关键说明 #

1. 泛型绑定类型关系：将Unit改为泛型类，参数T限定为UnitActions的子类型，让actionType和act的返回类型强关联，从根源上避免子类返回类型不兼容的问题。
2. 消除冗余声明：抽象子类如WoodenUnit只需指定泛型参数UnitActions.run，无需重复声明act方法的签名，TS会自动继承Unit<UnitActions.run>的约束，要求返回UnitRunResult。
3. 严格类型检查：具体子类实现act时，TS会自动校验返回值是否符合绑定的结果类型，避免返回错误类型。
4. 高层函数类型推断：泛型参数T让test函数能在switch分支中自动推断unit.act()的返回类型，保证类型安全。

关于actionType的思路 #

原思路用actionType区分逻辑是可行的，但结合泛型后，TS能更好地建立类型关联，避免在顶层Unit类中使用动态泛型方法导致的类型松散问题，同时让代码更简洁、类型更安全。

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