Comment créer une énumération comme un type dans TypeScript?

Je travaille sur un fichier de définitions pour l'API Google Maps pour TypeScript.

Et j'ai besoin de définir une énumération comme type par exemple. google.maps.Animationqui contient deux propriétés: BOUNCEet DROP.

Comment cela devrait-il être fait dans TypeScript?

TypeScript 0.9+ a une spécification pour les énumérations:

enum AnimationType {
    BOUNCE,
    DROP,
}

La virgule finale est facultative.

À partir de TypeScript 0.9 (actuellement une 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 se verront attribuer respectivement 0, 1 et 2. Si vous souhaitez définir explicitement ces nombres, vous pouvez le faire dans le cadre de la déclaration d'énumération.

Listing 6.2 Énumérations avec des membres explicites

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

var mySize = TShirtSize.Large;

Ces deux exemples proviennent directement de TypeScript pour les programmeurs JavaScript .

Notez que ceci est différent de la spécification 0.8. La spécification 0.8 ressemblait à ceci - mais elle a été marquée comme expérimentale et susceptible de changer, vous devrez donc mettre à jour tout ancien code:

Clause de non - responsabilité - cet exemple 0.8 serait cassé dans les versions plus récentes du compilateur TypeScript.

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

var mySize = TShirtSize.Large;

Cela 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 manuels:

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

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

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

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 enregistrera:

undefined  
2  
Blue

Parce qu'au moment d'écrire ceci, le Typescript Playground générera 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 une énumération id / string avec ce qui suit:

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 indiqué par @ iX3, Typescript 2.4 prend en charge les chaînes enum.

Voir: Créer une énumération avec des valeurs de chaîne dans Typescript

Réponse originale:

Pour les valeurs de membre String, TypeScript autorise uniquement les nombres en tant que valeurs de membre d'énumération. Mais il existe quelques solutions / hacks que vous pouvez mettre en œuvre;

Solution 1:

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

Il existe une solution simple: il suffit de convertir la chaîne littérale en any avant d'affecter:

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

solution 2:

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

Vous pouvez utiliser un littéral de chaîne comme type. Par exemple:

let foo: 'Hello';

Ici, nous avons créé une variable appelée foo qui permettra uniquement de lui attribuer la valeur littérale «Hello». 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 en eux-mêmes mais peuvent être combinés dans une union de types pour créer une abstraction puissante (et utile), par exemple:

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

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

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

Énumérations dactylographiées:

Les énumérations sont placées dans le langage dactylographié pour définir un ensemble de constantes nommées. L'utilisation d'énumérations peut nous faciliter la vie. La raison en est que ces constantes sont souvent plus faciles à lire que la valeur représentée par l'énumération.

Créer une énumération:

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

Cet exemple de la documentation dactylographiée explique très bien le fonctionnement des énumérations. Notez que notre première valeur d'énumération (Up) est initialisée avec 1. Tous les membres suivants de l'énumération de nombres sont ensuite automatiquement incrémentés à partir de cette valeur (c'est-à-dire Down = 2, Left = 3, Right = 4). Si nous n'avions pas initialisé la première valeur avec 1, l'énumération commencerait à 0, puis l'incrémentation automatique (c'est-à-dire Down = 1, Left = 2, Right = 3).

En utilisant une énumération:

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

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

Notez que de cette façon, nous sommes beaucoup plus descriptifs dans la façon dont nous écrivons notre code. Les énumérations nous empêchent fondamentalement d'utiliser des nombres magiques (des nombres qui représentent une entité parce que le programmeur leur a donné une signification dans un certain contexte). Les nombres magiques sont mauvais pour les raisons suivantes:

1. Nous devons réfléchir davantage, nous devons d'abord traduire le nombre en une entité avant de pouvoir raisonner sur notre code.
2. Si nous révisons notre code après un long moment, ou si d'autres programmeurs examinent notre code, ils ne savent pas nécessairement ce que signifient ces chiffres.