如何在TypeScript中避免使用any实现类方法调用逻辑？

你遇到的错误根源在于抽象类的构造器无法直接实例化：当你把构造器类型指定为typeof AbstractExampleClass时，TypeScript会推断该构造器的调用签名为never——因为抽象类本身不能被new关键字实例化，只能被子类继承。因此直接调用new cls()会触发类型错误。

下面是无需使用any的几种实现方案：

基础代码复现 #

先明确你的代码场景，方便后续方案演示：

abstract class AbstractExampleClass {
  public baseMethod(): void {
    console.log('Base method called');
  }
}

class ExampleClassOne extends AbstractExampleClass {
  public methodOne(): void {
    console.log('Method One called');
  }
}

class ExampleClassTwo extends AbstractExampleClass {
  public methodTwo(): void {
    console.log('Method Two called');
  }
}

// 原始配置对象
const classConfig = [
  { cls: ExampleClassOne, methods: ['methodOne', 'baseMethod'] },
  { cls: ExampleClassTwo, methods: ['methodTwo', 'baseMethod'] },
];

方案一：定义可实例化子类的构造器类型（推荐） #

通过自定义类型约束，明确构造器是能创建AbstractExampleClass子类实例的可调用构造函数，同时用泛型和keyof确保方法名的合法性：

// 定义构造器类型：约束为可实例化AbstractExampleClass子类的构造函数
type ConcreteClassConstructor<T extends AbstractExampleClass> = new () => T;

// 泛型函数，严格约束输入类型
function initializeObjectAndCallMethod<T extends AbstractExampleClass>(
  cls: ConcreteClassConstructor<T>,
  methods: Array<keyof T>
) {
  const instance = new cls(); // 此时构造器可正常调用，类型推断正确
  methods.forEach(method => {
    // 额外做函数类型校验，避免非函数属性被调用
    const func = instance[method];
    if (typeof func === 'function') {
      func.call(instance);
    }
  });
}

// 遍历配置调用函数
classConfig.forEach(item => {
  initializeObjectAndCallMethod(
    item.cls,
    item.methods as Array<keyof typeof item.cls.prototype>
  );
});

说明 #

• ConcreteClassConstructor<T> 明确了构造器可以被new，并返回AbstractExampleClass的子类实例
• Array<keyof T> 确保传入的方法名是实例的有效属性，避免拼写错误或传入非方法属性
• 类型断言as Array<keyof typeof item.cls.prototype>是为了让TypeScript识别配置中方法名的具体类型，若给配置对象定义更严格的类型（见方案二），可省略此断言

方案二：给配置对象定义严格类型 #

通过给配置对象指定联合类型，让TypeScript自动推断构造器和方法名的类型，无需额外断言：

// 复用方案一的ConcreteClassConstructor类型
type ConcreteClassConstructor<T extends AbstractExampleClass> = new () => T;

// 定义单个配置项的类型
type ClassConfigItem<T extends AbstractExampleClass> = {
  cls: ConcreteClassConstructor<T>,
  methods: Array<keyof T>
};

// 给配置对象指定联合类型，精准匹配每个子类的配置
const classConfig: (
  | ClassConfigItem<ExampleClassOne>
  | ClassConfigItem<ExampleClassTwo>
)[] = [
  { cls: ExampleClassOne, methods: ['methodOne', 'baseMethod'] },
  { cls: ExampleClassTwo, methods: ['methodTwo', 'baseMethod'] },
];

// 调用函数时无需类型断言
classConfig.forEach(item => {
  initializeObjectAndCallMethod(item.cls, item.methods);
});

说明 #

• 联合类型ClassConfigItem<ExampleClassOne> | ClassConfigItem<ExampleClassTwo>让TypeScript能精准识别每个配置项对应的子类和可用方法
• 完全避免了any，类型检查更严格，能在编译阶段发现方法名拼写错误等问题

方案三：用instanceof缩小类型范围（适合需子类专属逻辑的场景） #

如果需要在函数内部针对不同子类执行专属逻辑，可以用instanceof做类型收窄，让TypeScript准确识别实例的可用方法：

type ConcreteClassConstructor<T extends AbstractExampleClass> = new () => T;

function initializeObjectAndCallMethod(
  cls: ConcreteClassConstructor<AbstractExampleClass>,
  methods: string[]
) {
  const instance = new cls();

  if (instance instanceof ExampleClassOne) {
    // TypeScript自动识别为ExampleClassOne类型，可安全调用methodOne
    methods.forEach(method => {
      if (method in instance && typeof instance[method] === 'function') {
        instance[method]();
      }
    });
  } else if (instance instanceof ExampleClassTwo) {
    // 同理，识别为ExampleClassTwo类型
    methods.forEach(method => {
      if (method in instance && typeof instance[method] === 'function') {
        instance[method]();
      }
    });
  }
}

// 调用函数
classConfig.forEach(item => {
  initializeObjectAndCallMethod(item.cls, item.methods);
});

说明 #

• 适合需要针对不同子类做特殊处理的场景，类型收窄后无需担心方法调用的类型错误
• 缺点是如果子类数量较多，代码会比较冗余，此时推荐方案一或方案二

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