TypeScript预定义字符串字面量接口及类型兼容报错解惑

先复现你的代码场景 #

按照描述写出对应代码，错误会出现在const d: C = example这一行：

interface A {
  field: "Af";
  variant: "A";
  validation: boolean;
}

interface B {
  field: "Af";
  variant: "B";
  validation: number;
}

type C = A | B;

class Example {
  field: "Af";
  variant: "A" | "B";
  validation: boolean | number;

  constructor(props: { field: "Af"; variant: "A" | "B"; validation: boolean | number }) {
    this.field = props.field;
    this.variant = props.variant;
    this.validation = props.validation;
  }
}

function test(props: Omit<C, "field">) {
  const example = new Example({ ...props, field: "Af" });
  const d: C = example; // ❌ 类型错误：Example实例不能赋值给C
}

报错原因 #

1. 类型约束不匹配：
   C是可辨识联合类型，它要求variant和validation必须严格对应：variant: "A"时validation必须是boolean，variant: "B"时必须是number。
   但你的Example类实例的类型是{ field: "Af"; variant: "A" | "B"; validation: boolean | number }，这是C的超类型——它只保证两个字段的类型范围，不保证两者的对应关系（比如可能存在variant: "A"但validation: 123的非法情况），TypeScript会拒绝这种不安全的赋值。

2. Omit联合类型后的类型跟踪丢失：
   Omit<C, "field">的实际类型是({ variant: "A"; validation: boolean } | { variant: "B"; validation: number })，但当你把props和{ field: "Af" }合并后，TypeScript无法保留原联合成员中variant与validation的绑定关系，只能推断出一个宽泛的交叉类型，而不是原来的联合类型。

TypeScript类型系统依据 #

TypeScript对可辨识联合类型的类型检查依赖字段间的约束关系：只有当一个类型严格符合联合类型中某一个成员的全部约束时，才能被赋值给该联合类型。超类型由于存在不符合约束的可能性，会被类型检查器拒绝。同时，联合类型经过Omit等操作后，若后续操作破坏了原成员的字段绑定关系，类型检查器无法自动恢复这种绑定，导致类型变宽。

解决方案：用泛型保留类型绑定 #

要让test函数合法调用不报错、非法调用报错，同时能正确赋值给C类型变量，需要用泛型约束来保留variant和validation的对应关系：

interface A {
  field: "Af";
  variant: "A";
  validation: boolean;
}

interface B {
  field: "Af";
  variant: "B";
  validation: number;
}

type C = A | B;

// 让Example类接受泛型，约束为C的子类型
class Example<T extends C> {
  field: T["field"];
  variant: T["variant"];
  validation: T["validation"];

  constructor(props: T) {
    this.field = props.field;
    this.variant = props.variant;
    this.validation = props.validation;
  }
}

// 用泛型T约束props是C某一成员的Omit结果
function test<T extends C>(props: Omit<T, "field">) {
  // 断言合并后的props为T，因为我们明确知道它符合T的约束
  const example = new Example<T>({ ...props, field: "Af" } as T);
  const d: C = example; // ✅ 无错误，因为T是C的子类型
}

// 合法调用：符合A的约束
test({ variant: "A", validation: true });

// 合法调用：符合B的约束
test({ variant: "B", validation: 123 });

// 非法调用：variant与validation不匹配，触发报错
test({ variant: "A", validation: 123 }); // ❌ 类型错误

方案说明 #

• 泛型T会自动推导为C的具体成员（A或B），保留了variant和validation的绑定关系。
• Example<T>的实例类型严格对应C的某一个成员，因此可以安全赋值给C类型变量。
• 非法调用会因为不符合Omit<T, "field">的类型约束直接报错，达到预期的类型检查效果。

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