当基类是泛型时强制执行“typeof BaseClass”

Question

假设我有一个通用抽象基类和一组扩展基类并提供通用参数的类。

abstract class BaseClass<T> {
  constructor(protected container: T[]) { }
  static someStaticFunc(): string {
    return 'I\'m the BaseClass';
  }
  getElement(i: number): T {
    return this.container[i]
  }
}

class ConcreteClass1 extends BaseClass<number> {
  static someStaticFunc(): string {
    return 'I\'m ConcreteClass1'
  }

  addNumber(element: number) {
    this.container.push(element);
  }
}

class ConcreteClass2 extends BaseClass<string> {
  static someStaticFunc(): string {
    return 'I\'m ConcreteClass2'
  }

  addStringTwice(element: string) {
    this.container.push(element);
    this.container.push(element);
  }
}

class ConcreteClass3 extends BaseClass<boolean> {
    // Doesn't add anything
}

我定义了一个接口结构，其中每个值都必须是typeof BaseClass

interface SetOfBaseClasses {
  Class1: typeof BaseClass,
  Class2: typeof BaseClass,
  Class3: typeof BaseClass
};

我想创建一个该接口类型的对象，并将具体的类分配给它。然后调用类上的每一个静态函数，在底部得到预期的结果。

const classes: SetOfBaseClasses = {
  Class1: ConcreteClass1,
  Class2: ConcreteClass2,
  Class3: ConcreteClass3
}

console.log(classes.Class1.someStaticFunc());
console.log(classes.Class2.someStaticFunc());
console.log(classes.Class3.someStaticFunc());

// Expected output:
// I'm ConcreteClass1
// I'm ConcreteClass2
// I'm the BaseClass

但是，TypeScript 不认为 ConcreteClass1、ConcreteClass2 或 ConcreteClass3 与 typeof BaseClass 兼容。我认为这是因为 BaseClass 涉及的泛型。所以我也尝试了：

interface SetOfBaseClasses {
  Class1: typeof BaseClass<unknown>,
  Class2: typeof BaseClass<unknown>,
  Class3: typeof BaseClass<unknown>
};

更准确地说：

interface SetOfBaseClasses {
  Class1: typeof BaseClass<number>,
  Class2: typeof BaseClass<string>,
  Class3: typeof BaseClass<boolean>
};

在任何一种情况下，TypeScript 似乎都不允许在 typeof Class 之后使用泛型参数

界面中的每一行都有两个错误，如下所示：

Call signature, which lacks return-type annotation, implicitly has an 'any' return type.(7020)
Type parameter name cannot be 'number'.(2368)

有没有办法用 TypeScript 做这种事情？在涉及泛型之前，这种方法似乎一切正常。

Typescript Playground

Answer 1

typeof BaseClass 类型或多或少等价于这个：

type TypeofBaseClass =
  (abstract new <T>(container: T[]) => BaseClass<T>) &
  { someStaticFunc(): string };

const testTypeofBaseClass: TypeofBaseClass = BaseClass;

注意TypeofBaseClass本身不是generic（上面没有类型参数）；相反，它有一个通用的abstract construct signature。这很像一个泛型函数，因为泛型类型参数是在您调用时指定的，而不是在声明本身中。 typeof BaseClass 的值（或者更确切地说，它的具体通用子类，如 class ConcreteSubclass<T> extends BaseClass<T>）可以为编写 new ConcreteSubclass 的人想要的任何 T 构造一个 BaseClass<T>。它可以是 BaseClass<string> 或 BaseClass<number> 或其他任何东西。

那不是你想要的类型。

---

相反，你想要的类型更像是这样的：

type TypeofConcreteClass<T> =
  (new (container: T[]) => BaseClass<T>) &
  { someStaticFunc(): string; };

这是一个具体的构造函数，所以 abstract 被删除了。但更重要的是，泛型类型参数T 的范围已被移动。您希望能够指定 TypeofConcreteClass<number> ，它只能构造 BaseClass<number> 实例而不是其他任何东西。写new ConcreteClass1 的人将永远无法得到BaseClass<string>。

---

目前无法自动将typeof BaseClass 转换为TypeofConcreteClass<T> 而不会跳过丑陋的圈子。该语言实际上并没有办法以编程方式表示它们之间的关系。有关更多信息，请参阅 "TypeScript how to create a generic type alias for a generic function?" 及其答案。

对于上述情况，我建议只使用手动编写的TypeofConcreteClass<T> 定义。或者你可以通过做一些类似的事情来实现这一目标

type TypeofConcreteClass<T> =
  Pick<typeof BaseClass, keyof typeof BaseClass> &
  (new (container: T[]) => BaseClass<T>);

它以编程方式获取BaseClass 的所有static 属性/方法，同时手动写出构造签名。

---

让我们验证一下这是否符合您的要求：

interface SetOfBaseClasses {
  Class1: TypeofConcreteClass<number>,
  Class2: TypeofConcreteClass<string>,
  Class3: TypeofConcreteClass<boolean>
};

function main() {
  const classes: SetOfBaseClasses = {
    Class1: ConcreteClass1,
    Class2: ConcreteClass2,
    Class3: ConcreteClass3
  }

  console.log(classes.Class1.someStaticFunc());
  console.log(classes.Class2.someStaticFunc());
  console.log(classes.Class3.someStaticFunc());

  console.log(new classes.Class1([1, 2, 3]).getElement(2).toFixed(3)) // "3.000"
  console.log(new classes.Class2(["a", "b", "c"]).getElement(2).toUpperCase()) // "C"

}

编译没有错误，可以按需要工作。

Playground link to code