Wie erstelle ich einen Aufzählungstyp in TypeScript?

Ich arbeite an einer Definitionsdatei für die Google Maps-API für TypeScript.

Und ich muss eine Aufzählung wie Typ definieren, z. google.maps.Animationwelches zwei Eigenschaften enthält: BOUNCEund DROP.

Wie soll das in TypeScript gemacht werden?

TypeScript 0.9+ hat eine Spezifikation für Aufzählungen:

enum AnimationType {
    BOUNCE,
    DROP,
}

Das letzte Komma ist optional.

Ab TypeScript 0.9 (derzeit eine Alpha-Version) können Sie die Enum-Definition wie folgt verwenden:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Standardmäßig werden diesen Aufzählungen 0, 1 bzw. 2 zugewiesen. Wenn Sie diese Nummern explizit festlegen möchten, können Sie dies im Rahmen der Enum-Deklaration tun.

Listing 6.2: Aufzählungen mit expliziten Mitgliedern

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

var mySize = TShirtSize.Large;

Beide Beispiele wurden direkt aus TypeScript für JavaScript-Programmierer entfernt .

Beachten Sie, dass dies von der Spezifikation 0.8 abweicht. Die 0.8-Spezifikation sah folgendermaßen aus - sie wurde jedoch als experimentell markiert und wird sich wahrscheinlich ändern. Daher müssen Sie jeden alten Code aktualisieren:

Haftungsausschluss - Dieses 0.8-Beispiel würde in neueren Versionen des TypeScript-Compilers beschädigt.

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

var mySize = TShirtSize.Large;

Dies ist jetzt Teil der Sprache. Die Dokumentation hierzu finden Sie unter TypeScriptLang.org> Grundtypen> Aufzählung . Ein Auszug aus der Dokumentation zur Verwendung dieser Aufzählungen:

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

Oder mit manuellen Hintergrundnummern:

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

Sie können auch zum Enum-Namen zurückkehren, indem Sie beispielsweise verwenden Color[2].

Hier ist ein Beispiel, wie das alles zusammen passt:

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

Dies wird protokollieren:

undefined  
2  
Blue

Zum Zeitpunkt des Schreibens generiert der Typescript-Spielplatz diesen 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();

Nur ein weiterer Hinweis, dass Sie eine ID / Zeichenfolge mit den folgenden Aufzählungen erstellen können:

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


}

Update :

Wie von @ iX3 erwähnt, unterstützt Typescript 2.4 Enum-Strings.

Siehe: Erstellen Sie eine Aufzählung mit Zeichenfolgenwerten in Typescript

Ursprüngliche Antwort:

Für String-Member-Werte erlaubt TypeScript nur Zahlen als Enum-Member-Werte. Es gibt jedoch einige Lösungen / Hacks, die Sie implementieren können.

Lösung 1:

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

Es gibt eine einfache Lösung: Verwandeln Sie das String-Literal einfach in ein beliebiges, bevor Sie Folgendes zuweisen:

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

Lösung 2:

kopiert von: https://basarat.gitbooks.io/typescript/content/docs/types/literal-types.html

Sie können ein Zeichenfolgenliteral als Typ verwenden. Beispielsweise:

let foo: 'Hello';

Hier haben wir eine Variable namens foo erstellt, mit der nur der Literalwert 'Hello' zugewiesen werden kann. Dies wird unten gezeigt:

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

Sie sind für sich genommen nicht sehr nützlich, können aber zu einer Typvereinigung kombiniert werden, um eine leistungsstarke (und nützliche) Abstraktion zu erstellen, z.

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

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

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

Aufzählungen im Typoskript:

Aufzählungen werden in die Typoskriptsprache eingefügt, um eine Reihe benannter Konstanten zu definieren. Die Verwendung von Aufzählungen kann unser Leben erleichtern. Der Grund dafür ist, dass diese Konstanten oft leichter zu lesen sind als der Wert, den die Aufzählung darstellt.

Eine Aufzählung erstellen:

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

Dieses Beispiel aus den Typoskript-Dokumenten erklärt sehr gut, wie Aufzählungen funktionieren. Beachten Sie, dass unser erster Aufzählungswert (Up) mit 1 initialisiert wird. Alle folgenden Elemente der Zahlenaufzählung werden dann automatisch von diesem Wert inkrementiert (dh Down = 2, Left = 3, Right = 4). Wenn wir den ersten Wert nicht mit 1 initialisieren würden, würde die Aufzählung bei 0 beginnen und dann automatisch inkrementieren (dh Down = 1, Left = 2, Right = 3).

Verwenden einer Aufzählung:

Wir können auf folgende Weise auf die Werte der Aufzählung zugreifen:

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

Beachten Sie, dass diese Art und Weise wir viel mehr sind beschreibend in der Art und Weise schreiben wir unseren Code. Aufzählungen hindern uns grundsätzlich daran, magische Zahlen zu verwenden (Zahlen, die eine Entität darstellen, weil der Programmierer ihnen in einem bestimmten Kontext eine Bedeutung gegeben hat). Magische Zahlen sind aus folgenden Gründen schlecht:

1. Wir müssen genauer nachdenken, wir müssen zuerst die Zahl in eine Entität übersetzen, bevor wir über unseren Code nachdenken können.
2. Wenn wir unseren Code nach einer langen Zeit überprüfen oder andere Programmierer unseren Code überprüfen, wissen sie nicht unbedingt, was mit diesen Zahlen gemeint ist.