Comment créer ENUM comme le type dactylographiée?

En dactylographiées 0,9 (actuellement de version alpha), vous pouvez utiliser la définition enum comme ceci:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Par défaut, ces énumérations seront attribués 0, 1 et 2 respectivement. Si vous souhaitez définir explicitement ces chiffres, vous pouvez le faire dans le cadre de la déclaration de ENUM.

Listing 6.2 énumérations avec des membres explicites

enum TShirtSize {
  Small = 3,
  Medium = 5,
  Large = 8
}

var mySize = TShirtSize.Large;

Ces deux exemples soulevés directement sur tapuscrit pour les programmeurs JavaScript .

Notez que ceci est différent de la spécification 0.8. La spécification 0.8 ressemblait - mais il a été marqué comme expérimental et susceptible de changer, de sorte que vous aurez à mettre à jour l' ancien code:

Avertissement - cet exemple 0,8 serait cassé dans les nouvelles versions du compilateur dactylographiée.

enum TShirtSize {
  Small: 3,
  Medium: 5,
  Large: 8
}

var mySize = TShirtSize.Large;

Ce fait maintenant partie de la langue. Voir TypeScriptLang.org> Types de base> ENUM pour la documentation à ce sujet . Un extrait de la documentation sur l'utilisation de ces énumérations:

enum Color {Red, Green, Blue};
var c: Color = Color.Green;

Ou avec des numéros de support manuel:

enum Color {Red = 1, Green = 2, Blue = 4};
var c: Color = Color.Green;

Vous pouvez également revenir au nom de ENUM en utilisant par exemple Color[2].

Voici un exemple de la façon dont tout cela va de pair:

module myModule {
    export enum Color {Red, Green, Blue};

    export class MyClass {
        myColor: Color;

        constructor() {
            console.log(this.myColor);
            this.myColor = Color.Blue;
            console.log(this.myColor);
            console.log(Color[this.myColor]);
        }
    }
}

var foo = new myModule.MyClass();

Cela se connectera:

undefined  
2  
Blue

Parce que, au moment de la rédaction de ce, l'aire de jeu Tapuscrit va générer ce code:

var myModule;
(function (myModule) {
    (function (Color) {
        Color[Color["Red"] = 0] = "Red";
        Color[Color["Green"] = 1] = "Green";
        Color[Color["Blue"] = 2] = "Blue";
    })(myModule.Color || (myModule.Color = {}));
    var Color = myModule.Color;
    ;
    var MyClass = (function () {
        function MyClass() {
            console.log(this.myColor);
            this.myColor = Color.Blue;
            console.log(this.myColor);
            console.log(Color[this.myColor]);
        }
        return MyClass;
    })();
    myModule.MyClass = MyClass;
})(myModule || (myModule = {}));
var foo = new myModule.MyClass();

Juste une autre note que vous pouvez un ENUM id / string avec les éléments suivants:

class EnumyObjects{
    public static BOUNCE={str:"Bounce",id:1};
    public static DROP={str:"Drop",id:2};
    public static FALL={str:"Fall",id:3};


}

Mise à jour :

Comme l'a noté @ IX3, Tapuscrit 2.4 supporte les chaînes de ENUM.

Voir: Créer un ENUM avec des valeurs de chaîne dactylographiée

Réponse originale:

Pour les chaînes de valeurs membres, tapuscrit ne permet que des nombres en tant que valeurs membres de ENUM. Mais il y a quelques solutions / hacks que vous pouvez mettre en œuvre;

Solution 1:

copié à partir de : https://blog.rsuter.com/how-to-implement-an-enum-with-string-values-in-typescript/

Il y a une solution simple: Il suffit de jeter la chaîne littérale à tout avant d'attribuer:

export enum Language {
    English = <any>"English",
    German = <any>"German",
    French = <any>"French",
    Italian = <any>"Italian"
}

solution 2:

copié à partir de : https://basarat.gitbooks.io/typescript/content/docs/types/literal-types.html

Vous pouvez utiliser une chaîne de caractères comme un type. Par exemple:

let foo: 'Hello';

Ici, nous avons créé une variable appelée foo qui ne permettra la valeur littérale « Bonjour » à lui être attribué. Ceci est démontré ci-dessous:

let foo: 'Hello';
foo = 'Bar'; // Error: "Bar" is not assignable to type "Hello"

Ils ne sont pas très utiles sur leur propre mais peuvent être combinés dans une union de type pour créer un puissant (et utile) abstraction, par exemple:

type CardinalDirection =
    "North"
    | "East"
    | "South"
    | "West";

function move(distance: number, direction: CardinalDirection) {
    // ...
}

move(1,"North"); // Okay
move(1,"Nurth"); // Error!

Énumérations à tapuscrit:

Énumérations sont mis dans la langue dactylographiée pour définir un ensemble de constantes nommées. En utilisant les énumérations peuvent rendre notre vie plus facile. La raison est que ces constantes sont souvent plus faciles à lire que la valeur que représente l'ENUM.

Création d'un ENUM:

enum Direction {
    Up = 1,
    Down,
    Left,
    Right,
}

Cet exemple de la docs dactylographiée explique très bien comment fonctionnent les énumérations. Notez que notre première valeur ENUM (Up) est initialisé avec 1. Tous les membres du numéro ENUM sont alors suivantes auto incrémentée de cette valeur (ie vers le bas = 2, gauche = 3, Droite = 4). Si l' on n'a pas été initialisé la première valeur avec 1 l'ENUM commencerait à 0 puis incrémentation automatique (ie vers le bas = 1, Gauche = 2, Droite = 3).

L'utilisation d'un ENUM:

Nous pouvons accéder aux valeurs de l'ENUM de la manière suivante:

Direction.Up;     // first the enum name, then the dot operator followed by the enum value
Direction.Down;

Notez que cette façon , nous sommes beaucoup plus descriptif dans notre façon d' écrire notre code. Énumérations nous empêchent essentiellement d'utiliser les numéros de magie (numéros qui représentent une entité parce que le programmeur a donné un sens à eux dans un certain contexte). Les nombres magiques sont mauvais pour les raisons suivantes:

1. Nous devons réfléchir davantage, nous avons d'abord besoin de traduire le nombre à une entité avant de pouvoir raisonner sur notre code.
2. Si nous passons en revue notre code après un long moment, ou d'autres programmeurs en revue notre code, ils ne savent pas nécessairement ce que l'on entend avec ces chiffres.