web-dev-qa-db-fra.com

Comment créer enum comme type dans TypeScript?

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

Et je dois définir une énumération comme type, par exemple. google.maps.Animation qui contient deux propriétés: BOUNCE et DROP.

Comment cela devrait-il être fait dans TypeScript?

enumstypescript
109
eNepper

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

enum AnimationType {
    BOUNCE,
    DROP,
}

La virgule finale est facultative.

130
Steve Lucco

A partir de TypeScript 0.9 (version alpha actuellement), 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 0, 1 et 2 respectivement. Si vous souhaitez définir explicitement ces nombres, vous pouvez le faire dans le cadre de la déclaration enum.

Liste 6.2 Énumérations avec 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 étant expérimentale et susceptible de changer. mettre à jour tout ancien code:

Disclaimer - 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;
64
Fenton

Cela fait maintenant partie du langage. 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 numéros de sauvegarde manuels:

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

Vous pouvez également revenir au nom de l'énum 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 va enregistrer:

undefined  
2  
Blue

Parce que, au moment de l'écriture de 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();
23
Jeroen

Juste une autre note que vous pouvez un id/string enum 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};


}
14
done_merson

Mise à jour :

Comme noté 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 enum. Mais il y a quelques solutions/hacks que vous pouvez implémenter;

Solution 1:

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

Il existe une solution simple: il suffit de lancer le littéral chaîne sur n’importe lequel avant d’affecter:

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 un littéral de chaîne comme type. Par exemple:

let foo: 'Hello';

Ici, nous avons créé une variable appelée foo qui ne permettra que l’affectation de la valeur littérale "Hello". Ceci est démontré ci-dessous:

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

Elles ne sont pas très utiles en elles-mêmes mais peuvent être combinées dans une union de type 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!
8
Arthur

Énums en TypeScript:

Les énumérations sont placées dans le langage TypeScript pour définir un ensemble de constantes nommées. Utiliser des enums peut nous rendre la vie plus facile. La raison en est que ces constantes sont souvent plus faciles à lire que la valeur représentée par l’énumération.

Créer un enum:

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

Cet exemple tiré de la documentation TypeScript explique très bien le fonctionnement des énumérations. Notez que notre première valeur enum (Up) est initialisée avec 1. Tous les membres suivants du nombre enum sont alors incrémentés automatiquement à partir de cette valeur (c'est-à-dire Down = 2, Left = 3, Right = 4) . Si nous n’initialisions pas la première valeur avec 1, l’énumération commencerait à 0 puis s’incrémenterait automatiquement (c’est-à-dire Down = 1, Left = 2, Right = 3).

En utilisant un enum:

Nous pouvons accéder aux valeurs de l'énum 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 descriptif dans la façon dont nous écrivons notre code. Les énumérations nous empêchent fondamentalement d'utiliser nombres magiques (des nombres qui représentent une entité parce que le programmeur leur a donné un sens dans un certain contexte). Les nombres magiques sont mauvais pour les raisons suivantes:

  1. Nous devons réfléchir plus sérieusement. Nous devons d’abord traduire le numéro en une entité avant de pouvoir raisonner au sujet de notre code.
  2. Si nous examinons notre code après un long moment, ou si d'autres programmeurs révisent notre code, ils ne savent pas nécessairement ce que l'on entend par ces chiffres.
1
Willem van der Veen