Grundsätzlich muss ich eine statische Funktion einer als Parameter übergebenen Klasse verwenden:
BEARBEITEN:
Minimal reproduzierbares Beispiel.
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);
...nach der Bearbeitung der Frage.
Der generische Typ sollte typeof Vehicleseher erweitern als Vehicles:
function getVehicleByClass<T extends typeof Vehicles>(Vehicle: T) {
Vehicle.getAll();
}
Das heißt, ich könnte mir einen Typ geben für typeof Vehicles:
type VehiclesType = typeof Vehicles;
Dann:
function getVehicleByClass<T extends VehiclesType>(Vehicle: T) {
// −−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−−^
Vehicle.getAll();
}
...nur weil ich in kleineren Stücken besser denke. :-D
(Ich lasse das nur, weil du sagtest, es sei nützlich für einige andere Dinge, an denen du arbeitest...)
Was Sie haben, sollte funktionieren, ich vermute, das eigentliche Problem besteht darin, dass Sie keine Eingaben für Object.values(hinzugefügt in ES2017) haben. Sie sollten Ihre tsconfig.json überprüfen, um sicherzustellen, dass Ihre libOption ES2017 oder höher ist.
Wenn Sie die Eingaben für haben Object.values, funktioniert dies :
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);
}
});
}
... obwohl ich denke, dass ich einen Typ für diesen {[key: string]: typeof Model}Typ verwenden würde, da Sie ihn an mehreren Stellen verwenden:
type ModelValuesObject = { [key: string]: typeof Model };
Dann:
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);
}
});
}
Wenn Sie die minimale Änderung wünschen , können Sie den modelParameter Ihres forEachRückrufs eingeben:
Object.values(models).forEach((model: typeof Model) =>
Dadurch können Sie die staticMethode für die Klassen in modelden Werten von verwenden.
Aber TypeScript kann es ableiten. Hier habe ich es genommen {[key: string]: typeof Model}und ihm einen praktischen Namen gegeben, damit wir es wiederverwenden können:
type ModelValuesObject = { [key: string]: typeof Model };
Dann ist es:
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);
}
});
}
Dieser Artikel stammt aus dem Internet. Bitte geben Sie beim Nachdruck die Quelle an.
Bei Verstößen wenden Sie sich bitte [email protected] Löschen.
Lass mich ein paar Worte sagen