TypeScript子类重写方法缩小参数类型报错，如何解决？

TypeScript 对函数参数的类型检查遵循逆变原则：子类重写父类/接口的方法时，参数类型不能比原方法更严格。你的代码里，IBase 和 Base 的 foo 方法接受 AB[] 类型的参数，但 BaseA 的 foo 只接受 A[]——如果把 BaseA 实例当成 IBase 或 Base 使用，调用 foo 传入 B 类型参数会出现类型不兼容，所以 TypeScript 抛出了错误。

方案一：泛型约束（推荐，类型安全） #

把接口和抽象类改成泛型，通过泛型参数限定 foo 方法的允许参数类型，子类可以指定自己的专属类型，同时保持整体类型兼容。

enum EnumA {
    A,
    AYE
}

enum EnumB {
    B,
    BEE
}

type A = keyof typeof EnumA
type B = keyof typeof EnumB

type AB = A | B

// 泛型接口，用T约束允许的参数类型
interface IBase<T extends AB> {
    foo: (...ok: T[]) => IBase<T>
}

// 泛型抽象类，实现泛型接口
abstract class Base<T extends AB> implements IBase<T> {
    public foo(...ok: T[]): Base<T> {
        return this
    }
}

// 子类指定泛型参数为A
class BaseA extends Base<A> implements IBase<A> {
    public override foo(...ok: A[]): Base<A> {
        return super.foo(...ok)
    }
}

// 子类指定泛型参数为B
class BaseB extends Base<B> implements IBase<B> {
    public override foo(...ok: B[]): Base<B> {
        return super.foo(...ok)
    }
}

const myA: BaseA = new BaseA()
myA.foo("A") // 合法
myA.foo("B") // 报错，符合预期

方案二：移除子类的 implements IBase（简化场景） #

如果不需要把子类实例向上转型为 IBase，可以去掉子类的 implements IBase 声明。这种方式下，调用 myA.foo 时会自动提示 A 类型参数，但要注意：如果把 myA 赋值给 IBase 类型变量，TS 会允许传入 AB 类型参数，存在安全隐患。

enum EnumA {
    A,
    AYE
}

enum EnumB {
    B,
    BEE
}

type A = keyof typeof EnumA
type B = keyof typeof EnumB

type AB = A | B

interface IBase {
    foo: (...ok: AB[]) => IBase
}

abstract class Base implements IBase {
    public foo(...ok: AB[]): Base {
        return this
    }
}

// 移除implements IBase
class BaseA extends Base {
    public override foo(...ok: A[]): Base {
        return super.foo(...ok)
    }
}

class BaseB extends Base {
    public override foo(...ok: B[]): Base{
        return super.foo(...ok)
    }
}

const myA: BaseA = new BaseA()
myA.foo("A") // 合法
myA.foo("B") // 报错，符合预期

// 注意：向上转型会绕过类型检查，谨慎使用
const base: IBase = myA
base.foo("B") // TS不报错，但逻辑上不符合BaseA的设计

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