如何为TypeScript中不同基类的子类定义可复用泛型类型

我有一个返回类的对象如下：

export const ClassMap: INTERFACE = {
    create: CreateClass,
    update: UpdateClass,
    response: ResponseClass,
    export: ExportClass,
};

其中每个类分别拥有不同的基类：BaseCreate、BaseUpdate、BaseResponse、BaseExport。我想要为classMap对象指定一个带泛型的接口作为返回类型，该如何定义？

我尝试了以下写法：

type BaseClass<B, T extends B> = T & { new (): T & B };
interface MAP<Create, Update, Response, Export> {
    create: BaseClass<BaseCreate, Create>;
    update: BaseClass<BaseUpdate, Update>;
    response: BaseClass<BaseResponse, Response>;
    export: BaseClass<BaseExport, Export>;
}

但提示存在属性缺失问题，有没有更优的解决方案？

你的问题根源是BaseClass的定义混淆了类实例类型与类构造函数类型，导致TypeScript无法匹配实际的类构造函数，触发属性缺失报错。以下是更简洁准确的实现方案：

1. 定义精准的泛型接口 #

直接为每个字段指定「继承对应基类的构造函数」类型，无需额外封装BaseClass：

// 声明基类（根据实际业务调整）
class BaseCreate {}
class BaseUpdate {}
class BaseResponse {}
class BaseExport {}

// 泛型接口：每个泛型参数对应具体子类，且强制继承自指定基类
interface ClassMapInterface<
  Create extends BaseCreate,
  Update extends BaseUpdate,
  Response extends BaseResponse,
  Export extends BaseExport
> {
  create: new () => Create;
  update: new () => Update;
  response: new () => Response;
  export: new () => Export;
}

2. 约束ClassMap对象 #

用上述接口直接约束对象，传入具体子类作为泛型参数：

// 示例子类
class CreateClass extends BaseCreate {}
class UpdateClass extends BaseUpdate {}
class ResponseClass extends BaseResponse {}
class ExportClass extends BaseExport {}

// 显式指定泛型参数，完成类型约束
export const ClassMap: ClassMapInterface<CreateClass, UpdateClass, ResponseClass, ExportClass> = {
  create: CreateClass,
  update: UpdateClass,
  response: ResponseClass,
  export: ExportClass,
};

3. 自动推导泛型（简化写法） #

如果不想手动传入泛型参数，可通过辅助函数让TypeScript自动推导：

function createClassMap<
  C extends BaseCreate,
  U extends BaseUpdate,
  R extends BaseResponse,
  E extends BaseExport
>(map: {
  create: new () => C;
  update: new () => U;
  response: new () => R;
  export: new () => E;
}) {
  return map;
}

// 自动推导所有子类类型，无需手动指定泛型
export const ClassMap = createClassMap({
  create: CreateClass,
  update: UpdateClass,
  response: ResponseClass,
  export: ExportClass,
});

这种实现既清晰约束了每个类的继承关系，又避免了类型定义混淆的问题，完全适配你的需求。

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