如何让TypeScript识别子类方法返回不同类型？

原始JavaScript类结构如下：

class BasicType {
    coerce(value) {
        return String(value);
    }
    read(value) {
        return this.coerce(value);
    }
}

其中coerce方法始终返回string类型，但read方法的返回类型会随子类变化，比如：

class FloatType extends BasicType {
    read(value) {
        return Number(super.read(value));
    }
}

尝试用TypeScript实现该结构时，初始泛型写法报错：

class BasicType<T = string> {
    coerce(value: any): string {
        return String(value);
    }
    read(value: any): T {
        return this.coerce(value);
        // Type 'string' is not assignable to type 'T'.
        //   'T' could be instantiated with an arbitrary type which could be unrelated to 'string'
        // ts(2322)
    }
}

class FloatType<T = number> extends BasicType<T> {
    read(value: any): T {
        return Number(super.read(value));
        // Type 'number' is not assignable to type 'T'.
        //   'T' could be instantiated with an arbitrary type which could be unrelated to 'number'.
        // ts(2322)
    }
}

当子类再派生子类时错误更严重：

class IntegerType<T = number> extends FloatType<T> {
    read(value: any): T {
        return Math.floor(super.read(value));
        // `return`
        // Type 'number' is not assignable to type 'T'.
        //   'T' could be instantiated with an arbitrary type which could be unrelated to 'number'.
        // ts(2322)
        // `super.read(value)`
        // Argument of type 'T' is not assignable to parameter of type 'number'.
        // ts(2345)
    }
}

问题：哪里出错了？如何让TypeScript知道FloatType#read返回number类型，从而能在IntegerType#read中正常使用？

错误原因 #

你给每个类都声明了可外部自定义的泛型参数T，TypeScript无法保证T一定是string/number这类与类逻辑匹配的类型（比如用户可以实例化new FloatType<string>()），因此不允许直接将string/number赋值给不确定的T，这就是报错的核心原因。

你的需求是每个子类的read返回类型固定，泛型的作用应该是约束父类与子类的返回类型关联，而非开放给外部随意指定。

正确实现方式 #

不给子类单独声明泛型，而是让子类继承父类时指定具体的泛型类型，固定父类read的返回类型，子类也明确自身的返回类型：

// 父类用泛型T定义read方法的返回类型，默认值为string
class BasicType<T = string> {
    coerce(value: any): string {
        return String(value);
    }
    read(value: any): T {
        // 由于子类继承时会保证T兼容string（如number可从string转换），用双重断言绕过父类层面的类型检查
        return this.coerce(value) as unknown as T;
    }
}

// FloatType继承时指定T为number，父类read的返回类型被固定为number
class FloatType extends BasicType<number> {
    read(value: any): number {
        return Number(super.read(value));
    }
}

// IntegerType继承FloatType，继承的泛型类型已固定为number，无需额外指定
class IntegerType extends FloatType {
    read(value: any): number {
        return Math.floor(super.read(value));
    }
}

关键说明 #

1. 泛型的正确用法：父类泛型T用来定义read的返回类型，子类通过<number>明确该类型，而非让子类再开放泛型参数。
2. 类型断言的合理性：父类中的双重断言是因为在父类层面TS无法确认T与string的兼容性，但我们在子类继承时会保证这一点，因此属于合理的类型兼容处理。
3. 固定子类类型：子类不再声明泛型参数，直接继承已指定泛型类型的父类，read的返回类型明确，TS能正确推断类型并避免报错。

这样修改后，每个类的read返回类型清晰，子类间的方法调用也能被TS正确识别类型。

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