处理数组时如何在多个派生类实例间缩小TypeScript类型范围？

我尝试在forEach循环（代码片段最后一条语句）中缩小类型范围。此时TypeScript认为obj的类型是ObjA | ObjB（因为它直接将数组对应键的所有可能值合并为联合类型），但processObj方法需要的参数类型是ObjA & ObjB（TypeScript会把可能的参数列表合并成交叉类型），两者类型不匹配。但代码逻辑是正确的——数组元素的obj和cls是一一匹配的，可以安全一起使用。

type ObjBase = { id: string };

abstract class Base<T extends ObjBase> {
  abstract processObj(obj: T): string;

  useObj(obj: T) {
    return this.processObj(obj);
  }
}

// 模块A
type ObjA = { someKey: string } & ObjBase;

class DerivedA extends Base<ObjA> {
  processObj(obj: ObjA): string {
      return obj.id + obj.someKey;
  }
}

// 模块B
type ObjB = { otherKey: string } & ObjBase;

class DerivedB extends Base<ObjB> {
  processObj(obj: ObjB): string {
      return obj.id + obj.otherKey;
  }
}

const modules = [
  { obj: { id: 'a', someKey: '' } as ObjA, cls: new DerivedA() },
  { obj: { id: 'b', otherKey: '' } as ObjB, cls: new DerivedB() },
] as const;

modules.forEach(module => {
  module.cls.processObj(module.obj); // 此处出现类型错误
});

方法1：用泛型函数处理单个模块（推荐） #

创建一个泛型函数，让TypeScript明确追踪obj和cls的类型关联，forEach调用时就能正确推断类型，完全保留类型安全：

function processModule<T extends ObjBase>(module: { obj: T, cls: Base<T> }) {
  module.cls.processObj(module.obj);
}

modules.forEach(processModule);

这种方式既符合你复用统一逻辑的需求，又不会破坏类型检查机制。

方法2：给数组声明明确的泛型联合类型 #

通过显式定义数组元素的类型为Module<ObjA> | Module<ObjB>，让TypeScript保留每个元素内部的类型关联，避免合并成宽泛的联合类型：

type Module<T extends ObjBase> = { obj: T, cls: Base<T> };
const modules: (Module<ObjA> | Module<ObjB>)[] = [
  { obj: { id: 'a', someKey: '' }, cls: new DerivedA() },
  { obj: { id: 'b', otherKey: '' }, cls: new DerivedB() },
];

modules.forEach(module => {
  module.cls.processObj(module.obj);
});

如果模块数量不多，这种方式能清晰维护类型关联。

方法3：类型断言（不推荐） #

如果确定逻辑绝对正确，可以用类型断言跳过TypeScript的类型检查，但这会失去类型安全保障，仅适合临时应急场景：

modules.forEach(module => {
  (module.cls as Base<typeof module.obj>).processObj(module.obj);
});

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