Come creare enum come il tipo a macchina?

A partire dal dattiloscritto 0.9 (attualmente una versione alpha) è possibile utilizzare la definizione enum in questo modo:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Per default, questi elenchi saranno assegnati 0, 1 e 2 rispettivamente. Se si desidera impostare in modo esplicito questi numeri, è possibile farlo come parte della dichiarazione enum.

Listing 6.2 enumerazioni con i membri espliciti

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

var mySize = TShirtSize.Large;

Entrambi questi esempi sollevato direttamente dal dattiloscritto per i programmatori JavaScript .

Si noti che questo è diverso alla specifica 0.8. La specifica 0.8 guardato come questo - ma è stato marcato come sperimentale e destinata a cambiare, quindi dovrete aggiornare qualsiasi vecchio codice:

Diniego - questo 0,8 esempio potrebbe essere rotto nelle versioni più recenti del compilatore dattiloscritto.

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

var mySize = TShirtSize.Large;

Questo è ora parte del linguaggio. Vedere TypeScriptLang.org> tipi di base> enum per la documentazione su questo. Un estratto dalla documentazione su come utilizzare queste enumerazioni:

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

O con i numeri backing manuali:

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

Si può anche andare indietro al nome enum utilizzando per esempio Color[2].

Ecco un esempio di come tutto questo va di pari passo:

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

Questo registrerà:

undefined  
2  
Blue

Perché, al momento della stesura di questo, il dattiloscritto Playground genererà questo codice:

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

Solo un altro notare che è possibile un enum id / stringa con il seguente:

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


}

Aggiornamento :

Come notato da @ iX3, Carattere tipografico 2.4 ha il supporto per le stringhe enum.

Vedere: Creazione di un enum con valori di stringa in tipografico

risposta originale:

Per valori utente stringa, tipografico permette soltanto numeri come valori utente enum. Ma ci sono un paio di soluzioni / hack è possibile implementare;

Soluzione 1:

copiato da: https://blog.rsuter.com/how-to-implement-an-enum-with-string-values-in-typescript/

C'è una soluzione semplice: basta lanciare la stringa letterale a qualsiasi prima di assegnare:

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

Soluzione 2:

copiato da: https://basarat.gitbooks.io/typescript/content/docs/types/literal-types.html

È possibile utilizzare una stringa letterale come un tipo. Per esempio:

let foo: 'Hello';

Qui abbiamo creato una chiamata foo variabile che permetterà soltanto il valore letterale 'Ciao' da assegnare ad esso. Questo è dimostrato di seguito:

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

Essi non sono molto utili per conto loro, ma possono essere combinati in un tipo di unione per creare un potente (e utile) astrazione ad esempio:

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

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

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

Enumerazioni in dattiloscritto:

Enumerazioni sono messi in lingua dattiloscritto di definire una serie di costanti denominate. Uso enumerazioni possono rendere la nostra vita più facile. La ragione di questo è che queste costanti sono spesso più facili da leggere rispetto al valore che rappresenta l'enumerazione.

Creazione di un enum:

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

Questo esempio dalla documentazione dattiloscritto spiega molto bene come funzionano le enumerazioni. Si noti che il nostro primo valore enum (Up) viene inizializzato con 1. Tutti i seguenti membri del numero di enum sono quindi automaticamente incrementato da tale valore (cioè Giù = 2, Sinistra = 3, destra = 4). Se non è stato inizializzato il primo valore con 1 enum avrebbe cominciato a 0 e quindi incremento automatico (cioè Giù = 1, Sinistra = 2, destra = 3).

Utilizzando un enum:

Siamo in grado di accedere ai valori della enum nel modo seguente:

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

Si noti che in questo modo siamo molto più descrittivo nel nostro modo di scrivere il nostro codice. Enumerazioni fondamentalmente ci impediscono di usare numeri magici (numeri che rappresentano una qualche entità perché il programmatore ha dato un significato a loro in un certo contesto). Numeri magici sono male a causa dei seguenti motivi:

1. Abbiamo bisogno di pensare di più, abbiamo prima bisogno di tradurre il numero ad un soggetto prima di poter ragionare su nostro codice.
2. Se passiamo in rassegna il nostro codice, dopo un po 'lungo, o di altri programmatori rivedere il nostro codice, non necessariamente sanno cosa si intende con questi numeri.