子类实例为联合类型时，如何正确调用抽象父类的泛型方法？

我遇到了一个TypeScript类型不匹配问题，场景代码如下：

type ClassicRecord = {
    recordType: "classic";
    classicField: string;
}

type SplitRecord = {
    recordType: "split";
    splitField: number;
}

type RecordType = ClassicRecord | SplitRecord


abstract class Parent<U> {
    abstract _type: string;
    records: U[] = []

    public add(record: U) {
        this.records.push(record)
    }
}

class Classic extends Parent<ClassicRecord>{
    readonly _type = "classic";
}

class Split extends Parent<SplitRecord> {
    readonly _type = "split";
}

type Measurement = Classic | Split

const getMeasurement = (): Measurement => {
    if (Math.random() > 0.5) return new Classic();
    return new Split();
}

const getRecord = (): RecordType => {
    if (Math.random() > 0.5) return { recordType: "split", splitField: 33 }
    return { recordType: "classic", classicField: "33" }
}

const measurement = getMeasurement()
const record = getRecord()

// 报错：Argument of type 'RecordType' is not assignable to parameter of type 'never'.
//  The intersection 'ClassicRecord & SplitRecord' was reduced to 'never' because property 
// 'recordType' has conflicting types in some constituents.
//    Type 'ClassicRecord' is not assignable to type 'never'.
measurement.add(record)

目前我只能用嵌套if判断解决：

if (measurement instanceof Split) {
    if (record.recordType === "split") {
        measurement.add(record)
    }
}

但想知道有没有更优雅的TypeScript解决方案？或者我的实现结构本身是否不合理？

优雅解决方案 #

方案1：自定义类型守卫关联类型 #

编写通用类型守卫函数，通过对比标识字段让TypeScript自动推断类型匹配关系：

function canAddRecord(measurement: Measurement, record: RecordType): 
    measurement is (Classic & {add: (r: ClassicRecord) => void}) | (Split & {add: (r: SplitRecord) => void}) {
    return measurement._type === record.recordType;
}

if (canAddRecord(measurement, record)) {
    measurement.add(record);
}

这个守卫函数通过_type和recordType的一致性校验，让TypeScript确认两者类型匹配，安全放行add方法调用。

方案2：重构类型结构，建立强映射关系 #

通过类型映射表将Measurement和RecordType的关联固化，从根源上避免类型不匹配：

// 定义类型映射表，明确Measurement类型与Record类型的对应关系
type RecordTypeMap = {
    classic: ClassicRecord;
    split: SplitRecord;
}

abstract class Parent<T extends keyof RecordTypeMap> {
    abstract _type: T;
    records: RecordTypeMap[T][] = [];

    public add(record: RecordTypeMap[T]) {
        this.records.push(record);
    }
}

class Classic extends Parent<"classic"> {
    readonly _type = "classic" as const;
}

class Split extends Parent<"split"> {
    readonly _type = "split" as const;
}

type Measurement = Classic | Split

// 调整getRecord为带类型参数的函数，确保返回对应类型的Record
function getRecord<T extends keyof RecordTypeMap>(type: T): RecordTypeMap[T] {
    if (type === "split") return { recordType: "split", splitField: 33 } as RecordTypeMap[T];
    return { recordType: "classic", classicField: "33" } as RecordTypeMap[T];
}

// 基于Measurement的类型获取对应Record
const measurement = getMeasurement();
if (measurement._type === "classic") {
    const record = getRecord("classic");
    measurement.add(record);
} else {
    const record = getRecord("split");
    measurement.add(record);
}

这种方式通过RecordTypeMap建立强类型关联，让Parent类的泛型直接绑定到具体的Record类型，消除了类型歧义。

方案3：类型断言（谨慎使用） #

如果业务逻辑能确保两者类型一定匹配，可以用类型断言快速跳过检查，但会丢失TypeScript的类型安全保障，仅适合场景明确的情况：

measurement.add(record as typeof measurement.records[0]);

结构合理性分析 #

原有结构的核心问题是Measurement和RecordType的类型关联松散，TypeScript无法自动推断两者的匹配关系。通过自定义类型守卫或建立类型映射表，可以让类型关系更清晰，同时保留类型安全校验。

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