如何使用作为参数传递的类的静态函数

Question

基本上，我需要使用作为参数传递的类的静态函数：

编辑：

我没有正确解释自己，希望你能通过这个例子理解我。

最小的可重现示例。

const TABLES = {
  bike: [],
  car: []
};

class Vehicles {
  static table = "";
  static getAll<T extends Vehicles>(): T[] {
    return TABLES[this.table];
  }
}

class Bike extends Vehicles {
  static table = "bike";
}

class Car extends Vehicles {
  static table = "car";
}

function getVehicleByClass<T extends Vehicles>(Vehicle: typeof T) { // 'T' only refers to a type, but is being used as a value here.
  Vehicle.getAll();
}

getVehicleByClass<Car>(Car);

Answer 1

更新答案

...在对问题进行编辑之后。

泛型类型应该扩展typeof Vehicles而不是Vehicles：

function getVehicleByClass<T extends typeof Vehicles>(Vehicle: T) {
  Vehicle.getAll();
}

On the playground

也就是说，我可能会给自己一个类型为typeof Vehicles：

type VehiclesType = typeof Vehicles;

然后：

function getVehicleByClass<T extends VehiclesType>(Vehicle: T) {
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−^
  Vehicle.getAll();
}

On the playground

...只是因为我认为更小的部分更好。 :-D

原答案

（我离开这个只是因为你说它对你正在工作的其他一些东西很有用......）

你应该工作，我怀疑这里真正的问题是你没有输入 Object.values （在 ES2017 中添加）。您需要检查您的 tsconfig.json 以确保您的 lib 选项是 ES2017 或更高版本。

如果您有Object.values、this works 的类型：

class Model {
    static associate(models: { [key: string]: typeof Model }): { [key: string]: typeof Model } {
        return { foo: Model };
    }
}
class Model2 extends Model {
}
class Model3 extends Model {
}

async function createAssociations(models: { [key: string]: typeof Model }): Promise<void> {
  Object.values(models).forEach(model => {
    if (model.associate) {
      model.associate(models);
    }
  });
}

...虽然我认为我会为 {[key: string]: typeof Model} 类型使用一个类型，因为您在多个地方使用它：

type ModelValuesObject = { [key: string]: typeof Model };

然后：

class Model {
    static associate(models: ModelValuesObject): ModelValuesObject {
        return { foo: Model };
    }
}
class Model2 extends Model {
}
class Model3 extends Model {
}

async function createAssociations(models: ModelValuesObject): Promise<void> {
  Object.values(models).forEach(model => {
    if (model.associate) {
      model.associate(models);
    }
  });
}

---

如果您想要最小更改，您可以键入forEach 回调的model 参数：

Object.values(models).forEach((model: typeof Model) =>

这将允许您对 model 值中的类使用 static 方法。

但是 TypeScript 可以推断它。我在这里取了{[key: string]: typeof Model} 并给它起了一个方便的名字，以便我们可以重复使用它：

type ModelValuesObject = { [key: string]: typeof Model };

那就是：

class Model {
    static associate(models: ModelValuesObject): ModelValuesObject {
        return { foo: Model };
    }
}
class Model2 extends Model {
}
class Model3 extends Model {
}

async function createAssociations(models: ModelValuesObject): Promise<void> {
  Object.values(models).forEach(model => {
    if (model.associate) {
      model.associate(models);
    }
  });
}

On the playground