Geben Sie unterschiedliche Typen durch Zeichenfolgen in Typescript zurück

Question

Wenn wir zwei verschiedene Typen wie unten angegeben haben, wie können wir die Rückgabe der Funktion basierend auf einem Zeichenfolgenparameter ändern und nicht den generischen Typ angeben?

interface Type1 { typeName: string; }; 
interface Type2 { typeVersion: string; }; 
type AllTypes = Type1 | Type2; 

function returnTypes(t: string): AllTypes { 
    ... 
} 

const typeResult = returnTypes('type1'); 
console.log(typeResult.typeName); 

Hier ist die Rückgabe nicht definiert!

Answer 1

könnten Sie einen Vorlagentyp verwenden https://www.typescriptlang.org/docs/handbook/generics.html

private returnTypes<T>(arg:T): T { 
    return arg 
} 

Andernfalls würden Sie Schalter Fälle auf der Grundlage Ihrer arg

returnTypes(arg:string): AllTypes { 
    switch(arg){ 
     case "type1": return SomethingOfType1 
     case "type2": return SomethingOfType2 
    } 
} 

Ein bisschen mehr Informationen über festlegen müssen, was Sie versuchen zu erreichen könnte helfen.

Answer 2

Eine überladene Erklärung wie so

interface Type1 { typeName: string; }; 
interface Type2 { typeVersion: string; }; 
type AllTypes = Type1 | Type2; 

function returnTypes(t: 'type1'): Type1; 
function returnTypes(t: 'type2'): Type2; 
function returnTypes(t : 'type1' | 'type2'): AllTypes { 
    switch (t) { 
     case "type1": return { typeName: "test" }; 
     case "type2": return { typeVersion: "test" }; 
    } 
} 

console.log(returnTypes('type1').typeName); 
console.log(returnTypes('type2').typeVersion); 

Beachten Sie, dass, wenn Sie eine Funktion auf diese Weise überlasten, die Umsetzung Signatur Anrufer nicht zur Verfügung steht. Nur die zuvor angegebenen Deklarationen umfassen eine überladene Funktionsschnittstelle.

UPDATE: Feste und vollständiges Beispiel zu zeigen, dass Typoskript weiß, welche Art es zurückkehrt.

Answer 3

Ich bin mir nicht sicher, was Sie versuchen, aber es scheint wie Sie versuchen, eine Funktion zu definieren, die einen von mehreren Typen zurückgibt. Zum Beispiel würde die Funktion entweder Typ1 oder Typ2 zurückgeben. Wenn die beiden Typen keine gemeinsame Funktionalität haben, müssen Sie den Typ überprüfen, bevor Sie eine andere Methode für das zurückgegebene Objekt aufrufen.

Angenommen, die zurückgegebenen Objekte do teilen eine gemeinsame Funktionalität, wäre es besser, dies in einer Schnittstelle zu definieren und dann zu deklarieren, dass jeder zurückzugebende Objekttyp diese Schnittstelle implementiert.

Also als ein Beispiel.

interface CommonStuff { 
    someFunction(); 
    someOtherFunction(); 
} 

class Type1 implements CommonStuff { 
    someFunction() {} 
    someOtherFunction() {} 
} 

class Type2 implements CommonStuff { 
    someFunction() {} 
    someOtherFunction() {} 
} 

Dann haben einfach Ihre Funktion eine Art von CommonStuff Rückkehr vermeidet

returnTypes(str:String) : CommonStuff { 
    let x : Type1; 
    let y : Type2; 
    ... 
    const z = someCondition ? x : y ; 
    return z; 
} 

Diese benötigen den Typ später

const something = returnTypes("blah); 
something.someFunction(); // you know something has a someFunction() method.