TypeScript中访问子类专属属性：类型断言vs交叉类型哪种方法更优？

咱们先直接说结论：方案一是可行的，但有优化空间；方案二完全不符合你的场景，不应该使用。下面详细拆解每个方案的问题，再给出更优的行业常规做法。

为什么方案二不可行？ #

你提到的交叉类型A & B意味着参数必须同时拥有A和B的所有属性——也就是说，这个对象得既有a又有b字段，还得同时是A和B的实例。但你的实际场景是数组里的元素是A或B，不是两者的混合体。

如果强行用方案二，当你从Parent[]数组里传元素进去时，TypeScript会直接报错，因为Parent类型的对象不可能同时满足A和B的属性要求。这个方案从类型定义上就不符合你的业务场景，直接pass。

方案一的优缺点 #

方案一通过检查type字段后做类型断言，是能正常工作的，但它有两个小问题：

1. 类型断言是“我知道我在做什么”的强提示：如果有人手动修改了对象的type字段（比如把一个A实例的type改成了Type.B），运行时会访问不存在的b属性，导致报错——TypeScript无法帮你避免这种运行时错误。
2. 代码略显冗余：每次都要手动写item as A这种断言，不够简洁。

更优的行业常规做法：判别式联合类型 #

TypeScript对这种有共同判别字段（比如你的type）的继承/联合类型有专门的优化，叫做判别式联合类型，它能让编译器自动帮你做类型窄化，不需要手动断言。

优化后的代码示例 #

enum Type { A = "A", B = "B" }

// 父类保持不变
class Parent { type: Type }

// 子类里固定type的值，让TS能识别判别式
class A extends Parent { 
  type = Type.A; // 固定为Type.A，确保类型和字段一致
  a: string;
}

class B extends Parent { 
  type = Type.B;
  b: string;
}

// 把数组类型从Parent[]改成(A | B)[]，更准确地描述实际元素类型
const array: (A | B)[] = [new A(), new B()];

function getSpecificAttribute(item: A | B) {
  switch(item.type) {
    case Type.A:
      // TS自动知道item是A类型，直接访问a即可，不需要断言
      return item.a;
    case Type.B:
      return item.b;
    default:
      // 加一个never类型检查，确保覆盖所有可能的类型
      // 如果以后新增了子类C，这里会报错，提醒你补充分支
      const _exhaustiveCheck: never = item;
      throw new Error(`Unexpected type: ${_exhaustiveCheck}`);
  }
}

为什么这是最佳实践？ #

• 类型安全：编译器会根据type字段自动推断当前对象的具体类型，不需要手动断言，避免了人为错误。
• 可维护性：默认分支的never检查能帮你在新增子类时自动发现遗漏的分支，防止出现未处理的情况。
• 代码简洁：去掉了冗余的类型断言，代码更清爽。

如果必须使用Parent[]怎么办？ #

如果因为某些原因不能把数组改成(A | B)[]，可以用自定义类型守卫来替代单纯的类型断言，这样能在运行时也做类型检查，提升安全性：

// 自定义类型守卫，告诉TS如何判断一个Parent实例是A还是B
function isA(item: Parent): item is A {
  return item.type === Type.A;
}

function isB(item: Parent): item is B {
  return item.type === Type.B;
}

function getSpecificAttribute(item: Parent) {
  if (isA(item)) {
    // TS自动窄化类型为A
    return item.a;
  } else if (isB(item)) {
    return item.b;
  }
  throw new Error(`Unknown type: ${item.type}`);
}

这种方式比方案一更安全，因为类型守卫会在运行时验证type字段和实际类型的匹配性，而单纯的断言只是编译时的提示。

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