Come creare enumerazione come il tipo in TypeScript?

Sto lavorando a un file di definizioni per l'API di Google Maps per TypeScript.

E ho bisogno di definire un enum come il tipo es. google.maps.Animationche contiene due proprietà: BOUNCEe DROP.

Come dovrebbe essere fatto in TypeScript?

TypeScript 0.9+ ha una specifica per le enumerazioni:

enum AnimationType {
    BOUNCE,
    DROP,
}

La virgola finale è facoltativa.

A partire da TypeScript 0.9 (attualmente una versione alpha) puoi usare la definizione enum in questo modo:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Per impostazione predefinita, a queste enumerazioni verranno assegnati rispettivamente 0, 1 e 2. Se vuoi impostare esplicitamente questi numeri, puoi farlo come parte della dichiarazione enum.

Listato 6.2 Enumerazioni con membri espliciti

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

var mySize = TShirtSize.Large;

Entrambi questi esempi sono stati estratti direttamente da TypeScript per programmatori JavaScript .

Notare che questo è diverso dalla specifica 0.8. La specifica 0.8 assomigliava a questa, ma era contrassegnata come sperimentale e probabilmente cambierà, quindi dovrai aggiornare qualsiasi vecchio codice:

Dichiarazione di non responsabilità : questo esempio 0.8 verrebbe danneggiato nelle versioni più recenti del compilatore TypeScript.

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

var mySize = TShirtSize.Large;

Questo ora fa parte della lingua. Vedi 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 numeri di supporto manuali:

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

Puoi anche tornare al nome dell'enumerazione usando ad esempio Color[2].

Ecco un esempio di come tutto questo va insieme:

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é, nel momento in cui scrivo questo, il Typescript 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'altra nota che puoi enumerare un id / stringa con quanto segue:

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, Typescript 2.4 ha il supporto per le stringhe enum.

Vedi: Creare un enum con valori stringa in Typescript

Risposta originale:

Per i valori dei membri String, TypeScript consente solo i numeri come valori dei membri enum. Ma ci sono alcune soluzioni / hack che puoi 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 any 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 tipo. Per esempio:

let foo: 'Hello';

Qui abbiamo creato una variabile chiamata foo che consentirà solo di assegnarle il valore letterale "Hello". Ciò è dimostrato di seguito:

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

Non sono molto utili da soli ma possono essere combinati in un'unione di tipi per creare un'astrazione potente (e utile) 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:

Le enumerazioni vengono inserite nel linguaggio dattiloscritto per definire un insieme di costanti denominate. L'uso di enumerazioni può semplificarci la vita. La ragione di ciò è che queste costanti sono spesso più facili da leggere rispetto al valore rappresentato dall'enumerazione.

Creazione di un'enumerazione:

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

Questo esempio tratto dai documenti del dattiloscritto spiega molto bene come funzionano le enumerazioni. Nota che il nostro primo valore enum (Up) è inizializzato con 1. Tutti i seguenti membri del numero enum vengono quindi incrementati automaticamente da questo valore (cioè Down = 2, Left = 3, Right = 4). Se non inizializzassimo il primo valore con 1, l'enum inizierebbe da 0 e poi si autoincrementerebbe (es. Giù = 1, Sinistra = 2, Destra = 3).

Utilizzando un enum:

Possiamo accedere ai valori dell'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ù descrittivi nel modo in cui scriviamo il nostro codice. Gli enum fondamentalmente ci impediscono di usare numeri magici (numeri che rappresentano un'entità perché il programmatore ha dato loro un significato in un certo contesto). I numeri magici sono negativi per i seguenti motivi:

1. Dobbiamo pensare più a fondo, dobbiamo prima tradurre il numero in un'entità prima di poter ragionare sul nostro codice.
2. Se rivediamo il nostro codice dopo molto tempo o altri programmatori rivedono il nostro codice, non necessariamente sanno cosa si intende con questi numeri.