如何在TypeScript中指定返回带原型的构造函数/类类型？

咱先来明确核心：TypeScript里要表示构造函数（类）的类型，通常用new (...args: any[]) => T这个签名，其中T是实例类型。但要让它知道返回的构造函数包含原类的原型，得结合泛型和交叉类型来做，分两种常见场景给你唠唠：

场景1：通过类继承扩展（最推荐，类型自动推断） #

这种方式最省心，因为TypeScript会自动处理子类和父类的类型继承，原型上的属性自然能被识别。比如你写一个给原类加方法的扩展函数：

// 先定义构造函数的基础类型
type Constructor<T = object> = new (...args: any[]) => T;

function enhanceClass<T extends Constructor>(Base: T) {
  // 继承原类，添加新方法
  class Enhanced extends Base {
    enhancedMethod() {
      return `I'm enhanced! Original instance: ${JSON.stringify(this)}`;
    }
  }

  return Enhanced;
}

// 使用示例
class MyClass {
  value: string;
  constructor(value: string) {
    this.value = value;
  }

  originalMethod() {
    return this.value;
  }
}

const EnhancedMyClass = enhanceClass(MyClass);
const instance = new EnhancedMyClass("test");
instance.originalMethod(); // TypeScript能识别这个原方法
instance.enhancedMethod(); // 也能识别新增的方法

这里TypeScript会自动推断EnhancedMyClass的类型是继承自MyClass的构造函数，原型上的所有方法（包括原类和新增的）都能被正确提示。

场景2：动态修改原类的原型（需要显式声明类型） #

如果你是直接修改原类的原型而不是创建子类，那得手动告诉TypeScript原型的变化，这时候要用交叉类型来扩展构造函数的原型类型：

type Constructor<T = object> = new (...args: any[]) => T;

// 定义返回类型：原构造函数 + 扩展后的原型
function addPrototypeMethod<T extends Constructor>(
  Base: T
): T & { prototype: T['prototype'] & { newPrototypeMethod: () => string } } {
  // 动态给原型加方法
  Base.prototype.newPrototypeMethod = function() {
    return "New method from prototype!";
  };

  // 类型断言，告诉TS我们修改了原型
  return Base as T & { prototype: T['prototype'] & { newPrototypeMethod: () => string } };
}

// 使用示例
class MyClass {
  originalMethod() {
    return "Original method";
  }
}

const ModifiedMyClass = addPrototypeMethod(MyClass);
const instance = new ModifiedMyClass();
instance.originalMethod(); // 正常识别原方法
instance.newPrototypeMethod(); // TypeScript现在能识别这个新增的原型方法

额外：保留原类的静态成员 #

如果你的原类有静态属性/方法，要让扩展后的构造函数类型也包含这些，只需要确保泛型约束包含静态部分就行：

// T是实例类型，S是静态成员类型
type ConstructorWithStatic<T = object, S = Record<string, any>> = new (...args: any[]) => T & S;

function enhanceWithStatic<T extends Constructor, S extends Record<string, any>>(
  Base: T & S
): T & S & { prototype: T['prototype'] & { newMethod: () => string } } {
  // 扩展静态属性
  Base.staticProperty = "Static value added!";
  // 扩展原型方法
  Base.prototype.newMethod = () => "New prototype method";

  return Base as T & S & { prototype: T['prototype'] & { newMethod: () => string } };
}

// 使用示例
class MyClass {
  static staticMethod() {
    return "Original static method";
  }
  instanceMethod() {
    return "Original instance method";
  }
}

const EnhancedMyClass = enhanceWithStatic(MyClass);
EnhancedMyClass.staticMethod(); // 识别原静态方法
EnhancedMyClass.staticProperty; // 识别新增的静态属性
const instance = new EnhancedMyClass();
instance.instanceMethod(); // 识别原实例方法
instance.newMethod(); // 识别新增的实例方法

关键总结 #

• 用new (...args: any[]) => T表示构造函数类型，泛型T绑定实例类型
• 子类继承的方式最省心，TS自动推断原型类型
• 动态修改原型时，用交叉类型T & { prototype: ... }显式声明原型的扩展
• 要保留静态成员，把静态部分的类型也加入泛型约束和返回类型

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