Tapuscrit de Type 'string' est pas assignable à type de

Vous aurez besoin de la lancer:

export type Fruit = "Orange" | "Apple" | "Banana";
let myString: string = "Banana";

let myFruit: Fruit = myString as Fruit;

Notez également que lors de l'utilisation de les littéraux de chaîne vous avez besoin d'utiliser un seul |

Je vois c'est un peu vieux, mais il pourrait y avoir une meilleure solution ici.

Quand vous voulez une chaîne de caractères, mais vous souhaitez que la chaîne de seulement certaines valeurs, vous pouvez utiliser les enums.

Par exemple:

enum Fruit {
    Orange = "Orange",
    Apple  = "Apple",
    Banana = "Banana"
}

let myFruit: Fruit = Fruit.Banana;

Maintenant, vous savez que peu importe ce que, myFruit sera toujours la chaîne "Banane" (Ou tout autre énumérable valeur que vous choisissez). Ceci est utile pour beaucoup de choses, que ce soit le regroupement des valeurs similaires comme cela, ou la cartographie convivial valeurs de machine-amicale des valeurs, tout en appliquant et en limitant les valeurs le compilateur va permettre.

Il existe plusieurs situations qui vous donne cette erreur. Dans le cas de l'OP, il y avait une valeur défini explicitement comme une chaîne. Donc, je suppose que peut-être ce qui est venu à partir d'une liste déroulante ou un service web ou un raw chaîne JSON.

Dans ce cas, un simple cast <Fruit> fruitString ou fruitString as Fruit est la seule solution (voir les autres réponses). Vous n'auriez jamais être en mesure d'améliorer cette situation au moment de la compilation.

Cependant, il est très facile à exécuter dans ce même message d'erreur lors de l'utilisation de constantes dans votre code que ne sont pas destinés à être de type string. Ma réponse se concentre sur ce deuxième scénario:

---

Tout d'abord: Pourquoi la "magie" des constantes de chaîne souvent mieux qu'un enum?

• J'aime la façon dont une chaîne de caractères constante semble contre un enum - il est compact et 'javascripty'
• A plus de sens si le composant que vous utilisez déjà utilise des constantes de chaîne.
• Avoir à importer un "type enum' juste pour obtenir une valeur de l'énumération peut être gênant en soi
• Quoi que je fasse je veux qu'il soit compiler sûr donc, si je ajouter ou supprimer une valeur valide à partir du type d'union, ou faites une erreur de saisie, ensuite, il FAUT donner une erreur de compilation.

Heureusement lorsque vous définir:

export type FieldErrorType = 'none' | 'missing' | 'invalid'

...vous êtes réellement définir un union de types où 'missing' est en fait un type de!

J'ai souvent courir dans le groupe "non cessible d'erreur" si j'ai une chaîne comme 'banana' dans mon tapuscrit et le compilateur pense je voulais dire comme une chaîne de caractères, alors que je voulais vraiment pour être de type banana. La façon intelligente le compilateur est capable d'être dépendra de la structure de votre code.

Voici un exemple de quand j'ai eu cette erreur aujourd'hui:

//this gives me the error 'string is not assignable to type FieldErrorType'
fieldErrors: [ { fieldName: 'number', error: 'invalid' } ]

Dès que j'ai su que 'invalid' ou 'banana' peut être soit un type ou d'une chaîne, j'ai réalisé que je pouvais juste affirmer une chaîne dans ce type de. Essentiellement jeté à elle-même, et de dire au compilateur non, je ne veux pas que ce soit une chaîne de caractères!

//so this gives no error, and I don't need to import the union type too
fieldErrors: [ { fieldName: 'number', error: <'invalid'> 'invalid' } ]

Quel est donc le problème avec juste "casting" pour FieldErrorType (ou Fruit)

//why not do this?
fieldErrors: [ { fieldName: 'number', error: <FieldErrorType> 'invalid' } ]

Ce n'est pas le temps de compilation sûre:

 <FieldErrorType> 'invalidddd';  //COMPILER ALLOWS THIS - NOT GOOD!
 <FieldErrorType> 'dog';         //COMPILER ALLOWS THIS - NOT GOOD!
 'dog' as FieldErrorType;        //COMPILER ALLOWS THIS - NOT GOOD!

Pourquoi? C'est la machine de sorte <FieldErrorType> est une affirmation et vous dire au compilateur un chien est un FieldErrorType! Et le compilateur va permettre!

MAIS si vous ne le suivant, puis le compilateur convertit la chaîne de caractères à un type

 <'invalid'> 'invalid';     //THIS IS OK  - GOOD
 <'banana'> 'banana';       //THIS IS OK  - GOOD
 <'invalid'> 'invalidddd';  //ERROR       - GOOD
 <'dog'> 'dog';             //ERROR       - GOOD

Il suffit de regarder dehors pour des imbéciles fautes de frappe comme ceci:

 <'banana'> 'banan';    //PROBABLY WILL BECOME RUNTIME ERROR - YOUR OWN FAULT!

Une autre façon de résoudre le problème par la coulée de l'objet parent:

Mon définitions ont été comme suit:

type d'exportation FieldName = 'nombre' | 'expirationDate' | 'cvc';
type d'exportation FieldError = 'none' | 'manquant' | 'invalide';
type d'exportation FieldErrorType = { field: FieldName, erreur: FieldError };

Disons que nous obtenons une erreur avec ce (la chaîne non cessible d'erreur):

  fieldErrors: [ { field: 'number', error: 'invalid' } ]

Nous pouvons "faire valoir" l'ensemble de l'objet en tant que FieldErrorType comme ceci:

  fieldErrors: [ <FieldErrorType> { field: 'number', error: 'invalid' } ]

Puis nous éviter d'avoir à faire <'invalid'> 'invalid'.

Mais ce que sur les fautes de frappe? Ne pas <FieldErrorType> juste affirmer tout ce qui est sur le droit d'être de ce type. Pas dans ce cas - heureusement, le compilateur SERA plaindre si vous faites cela, parce qu'il est assez intelligent pour savoir que c'est impossible:

  fieldErrors: [ <FieldErrorType> { field: 'number', error: 'dog' } ]