如何在TypeScript抽象类中强制子类实现静态抽象属性？

方案1：类装饰器+编译/运行期双重校验 #

TypeScript虽不支持静态抽象属性，但可通过类装饰器在编译期强制子类定义指定静态属性，同时在运行期做校验兜底，无需子类额外实现接口。

代码示例：

// 定义WeaponType类型
type WeaponType = "sword" | "bow" | "staff";

// 定义需强制的静态属性类型
type WeaponStaticProps = {
  buildsUpInto: typeof Weapon | null;
  defaultWeapon: boolean;
  name: string;
};

// 类装饰器：强制子类拥有指定静态属性
function EnforceStaticWeaponProps<T extends { new(...args: any[]): {} }>(constructor: T) {
  const requiredProps: (keyof WeaponStaticProps)[] = ["buildsUpInto", "defaultWeapon", "name"];
  // 运行期校验
  for (const prop of requiredProps) {
    if ((constructor as unknown as WeaponStaticProps)[prop] === undefined) {
      throw new Error(`Weapon子类 ${constructor.name} 未定义静态属性 ${String(prop)}`);
    }
  }
  // 编译期类型约束：让TS识别构造函数的静态属性
  return constructor as T & WeaponStaticProps;
}

// 抽象类定义
abstract class Weapon<T extends WeaponType> {
  // 通过getter映射静态属性为实例属性，保持原有调用习惯
  get buildsUpInto() {
    return (this.constructor as unknown as WeaponStaticProps).buildsUpInto;
  }

  get defaultWeapon() {
    return (this.constructor as unknown as WeaponStaticProps).defaultWeapon;
  }

  get name() {
    return (this.constructor as unknown as WeaponStaticProps).name;
  }
}

// 子类实现：直接添加静态属性并使用装饰器
@EnforceStaticWeaponProps
class IronSword extends Weapon<"sword"> {
  static buildsUpInto = SteelSword;
  static defaultWeapon = true;
  static name = "Iron Sword";
}

@EnforceStaticWeaponProps
class SteelSword extends Weapon<"sword"> {
  static buildsUpInto = null;
  static defaultWeapon = false;
  static name = "Steel Sword";
}

方案2：构造函数类型约束+抽象类静态方法 #

通过定义构造函数的类型约束，让TS在编译期自动检查子类的静态属性，同时抽象类提供静态方法统一访问属性，避免重复类型断言。

代码示例：

type WeaponType = "sword" | "bow" | "staff";

// 约束子类构造函数必须包含的静态属性
type WeaponConstructor<T extends WeaponType> = {
  new(): Weapon<T>;
  buildsUpInto: WeaponConstructor<any> | null;
  defaultWeapon: boolean;
  name: string;
};

abstract class Weapon<T extends WeaponType> {
  // 静态方法：统一访问静态属性
  static getBuildsUpInto<T extends WeaponType>(this: WeaponConstructor<T>) {
    return this.buildsUpInto;
  }

  static isDefaultWeapon<T extends WeaponType>(this: WeaponConstructor<T>) {
    return this.defaultWeapon;
  }

  static getName<T extends WeaponType>(this: WeaponConstructor<T>) {
    return this.name;
  }

  // 实例方法复用静态属性
  get buildsUpInto() {
    return (this.constructor as WeaponConstructor<T>).buildsUpInto;
  }
}

// 子类实现：TS自动检查静态属性是否符合约束
class IronSword extends Weapon<"sword"> {
  static buildsUpInto = SteelSword;
  static defaultWeapon = true;
  static name = "Iron Sword";
}

class SteelSword extends Weapon<"sword"> {
  static buildsUpInto = null;
  static defaultWeapon = false;
  static name = "Steel Sword";
}

方案3：单例模式替代静态属性 #

若核心需求是在图结构中通过“唯一标识”区分顶点，可改用单例模式：每个Weapon子类仅实例化一次，通过实例引用判断顶点相等，同时保留属性的不可变性。

代码示例：

type WeaponType = "sword" | "bow" | "staff";

abstract class Weapon<T extends WeaponType> {
  readonly buildsUpInto: Weapon<any> | null;
  readonly defaultWeapon: boolean;
  readonly name: string;

  protected constructor(buildsUpInto: Weapon<any> | null, defaultWeapon: boolean, name: string) {
    this.buildsUpInto = buildsUpInto;
    this.defaultWeapon = defaultWeapon;
    this.name = name;
  }
}

// 单例子类：仅暴露唯一实例
class IronSword extends Weapon<"sword"> {
  static readonly instance = new IronSword(SteelSword.instance, true, "Iron Sword");
  private constructor(buildsUpInto: Weapon<any> | null, defaultWeapon: boolean, name: string) {
    super(buildsUpInto, defaultWeapon, name);
  }
}

class SteelSword extends Weapon<"sword"> {
  static readonly instance = new SteelSword(null, false, "Steel Sword");
  private constructor(buildsUpInto: Weapon<any> | null, defaultWeapon: boolean, name: string) {
    super(buildsUpInto, defaultWeapon, name);
  }
}

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