Retour type différent par une chaîne dans Typescript

Question

Étant donné que nous avons deux types différents comme ci-dessous, comment pouvons-nous changer le retour de la fonction en fonction d'un paramètre de chaîne et de ne pas fournir le type générique?

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); 

Ici le retour n'est pas défini!

Answer 1

Vous pouvez utiliser un type de modèle https://www.typescriptlang.org/docs/handbook/generics.html

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

Sinon, vous auriez à régler les cas de commutation en fonction de votre arg

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

Un peu plus d'informations sur ce que vous essayez de accomplir pourrait aider.

Answer 2

Créer une déclaration surchargée comme si

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); 

Notez que lorsque vous surchargez une fonction de cette manière, la signature de la mise en œuvre ne sont pas disponibles aux appelants. Seules les déclarations spécifiées au préalable comprennent une interface de fonction surchargée.

MISE À JOUR: Exemple fixe et complété pour montrer que TypeScript sait quel type il retourne.

Answer 3

Je ne suis pas sûr de ce que vous essayez de faire, mais il semble comme vous essayez de définir une fonction qui renvoie un de plusieurs types. Ainsi, par exemple, la fonction retournera Type1 ou Type2. À moins que les deux types partagent un ensemble commun de fonctionnalités, vous devrez alors vérifier le type avant d'appeler une méthode potentiellement différente sur l'objet retourné.

En supposant que les objets que vous retournez faire partagent un ensemble de fonctionnalités, il serait préférable de définir que dans une interface, puis déclarer que chaque type d'objet que vous souhaitez revenir implémente cette interface.

Donc, à titre d'exemple.

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

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

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

Puis ont simplement votre fonction retourne un type de CommonStuff

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

Cela évite besoin de vérifier le type plus tard

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