Verwenden eines Typs als Parameter Typescript

Question

Verwendung eines Typs als Parameter in Typescript

type myType = {}
const passingType = (t: Type) => {
    const x : t = {}
}

passingType(myType);

Ich bekomme TS-Fehler

't' refers to a value, but is being used as a type here. Did you mean 'typeof t'?

und

'myType' only refers to a type, but is being used as a value here.ts(2693)

für den Anruf

jede Idee, wie dies erreicht werden kann.

Answer 1

Das ist nicht möglich.

---

Das statische Typsystem von TypeScript (das Ihre myTypeDefinition und Typanmerkungen enthält) wird gelöscht, wenn der Code als JavaScript ausgegeben wird. JavaScript wird tatsächlich zur Laufzeit ausgeführt. Zur Laufzeit können Sie nur auf Werte zugreifen . Typlöschung bedeutet, dass Ihr Code oben ungefähr so ​​aussieht:

const passingType = (t) => {
    const x = {};
};
passingType(myType);

Es gibt keinen Wert, myTypean den übergeben werden kann passingType.

Und da TypeScript-Typen zur Laufzeit nicht als Werte vorhanden sind, gibt es keinen "Typtyp" wie den, den Sie aufrufen Type. Dieser Ansatz ist also, wie gesagt, nicht direkt möglich.

---

Anstatt darüber nachzudenken, einen "Typ" zur Laufzeit an eine Funktion zu übergeben, was nicht fruchtbar ist, ist es wahrscheinlich am besten, genau darüber nachzudenken, was zur Laufzeit in reinem JavaScript geschehen soll, und dann Typen zu schreiben, um dies zu unterstützen.

Was möchten Sie zur Laufzeit wirklich mit einem "Typ" machen? Möchten Sie damit überprüfen, ob ein Wert von diesem Typ ist? Anstatt einen Typ zu übergeben, möchten Sie möglicherweise eine Typschutzfunktion übergeben :

type Guard<T> = (x: any) => x is T;
const passingType = <T,>(t: Guard<T>) => {
    if (t(undefined)) {
        console.log("undefined IS of the guarded type T");
    }  else {
        console.log("undefined is NOT of the guarded type T");
    }
}

Und Sie könnten es so verwenden:

function isUndefined(x: any): x is undefined {
    return typeof x === "undefined";
}

passingType(isUndefined); // undefined IS of the guarded type T

function isNumber(x: any): x is number {
    return typeof x === "number";
}
passingType(isNumber); // undefined IS NOT of the guarded type T

function isNumberOrUndefined(x: any): x is number | undefined {
    return isNumber(x) || isUndefined(x);
}

passingType(isNumberOrUndefined); // undefined IS of the guarded type T

Ihr tatsächlicher Anwendungsfall bestimmt die Anforderungen, wie das Argument passingTypeaussehen soll. Es kann sich um eine gesamte Datenstruktur handeln, die verschiedene Dinge darstellt, die Sie zur Laufzeit mit einem "Typ" tun möchten. Selbst wenn dieses Beispiel für einen Typschutz für Sie nicht funktioniert, ist es möglich, dass etwas anderes funktioniert.

---

Die kurze Antwort lautet jedoch erneut, dass das statische Typensystem von TypeScript gelöscht wird und es daher unmöglich ist, zur Laufzeit direkt auf seine Typen zu verweisen.

Spielplatz Link zum Code

Answer 2

Verwenden Sie stattdessen Generika. Typargumente haben eine andere Syntax als ausgegebene JS-Argumente. Zum Beispiel:

type TheType = |
  { foo: string } |
  { bar: string };
const passingType = <T extends TheType>(obj: T) => {
    return { ...obj };
};

const result = passingType({ foo: 'foo' });

Dies führt dazu result, dass ein neues Objekt, das innerhalb der Funktion erstellt wurde, ordnungsgemäß als eingegeben wird { foo: string }.