Wie Enum wie Typ in Typoskript zu schaffen?

Ab Typoskript 0,9 (zur Zeit einer Alpha-Version) können Sie die Enum-Definition wie folgt verwendet werden:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Standardmäßig werden diese Aufzählungen 0, 1 bzw. 2 zugeordnet werden. Wenn Sie diese Zahlen explizit festlegen möchten, können Sie dies im Rahmen der ENUM Erklärung tun.

Listing 6.2 Aufzählungen mit expliziten Mitglieder

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

var mySize = TShirtSize.Large;

Beide Beispiele angehoben direkt aus Typoskript für JavaScript - Programmierer .

Beachten Sie, dass dies auf die 0,8 - Spezifikation unterscheidet. Die 0,8 - Spezifikation sah wie folgt aus - aber es wurde als experimentelle und wahrscheinlich ändern markiert, so dass Sie alle alten Code aktualisieren:

Haftungsausschluss - das 0,8 Beispiel wäre in neueren Versionen des Typoskript Compiler gebrochen werden.

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

var mySize = TShirtSize.Large;

Dies ist nun Teil der Sprache. Siehe TypeScriptLang.org> Grundtypen> Enum für die Dokumentation zu diesem Thema . Ein Auszug aus der Dokumentation, wie diese Aufzählungen verwenden:

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

Oder mit manueller Unterstützung Zahlen:

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

Sie können auch unter Verwendung von zum Beispiel an die ENUM - Namen zurück Color[2].

Hier ist ein Beispiel dafür, wie das alles zusammen geht:

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

undefined  
2  
Blue

Da zum Zeitpunkt der Abfassung dieses, generiert der Typoskript 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 weiteres beachten Sie, dass können Sie eine ID / string Enum mit den folgenden:

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 durch @ Ix3 erwähnt, Typoskript 2.4 hat die Unterstützung für ENUM - Strings.

Siehe: Erstellen Sie eine Enumeration mit String - Werte in Typoskript

Original Antwort:

Für String Elementwerte ermöglicht Typoskript nur Zahlen als ENUM-Elementwerte. Aber es gibt ein paar Lösungen / Hacks Sie implementieren können;

Lösung 1:

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

Es gibt eine einfache Lösung: Guss einfach den Stringliteral einen vor zuweisen:

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

Lösung 2:

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

Sie können einen Stringliteral als Typ verwenden. Beispielsweise:

let foo: 'Hello';

Hier haben wir eine Variable namens foo erstellt, die nur die wörtliche Wert ‚Hallo‘ ermöglicht es ihm zugewiesen werden. Dies wird im Folgenden gezeigt:

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

Sie sind nicht sehr nützlich, auf ihrem eigenen, sondern in einer Art Vereinigung kombiniert werden, um einen leistungsfähigen (und nützlich) Abstraktion zB zu erstellen:

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

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

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

Aufzählungen in Typoskript:

Aufzählungen werden in die Typoskript Sprache setzen einen Satz benannter Konstanten zu definieren. Mit Aufzählungen können unser Leben leichter machen. Der Grund dafür ist, dass diese Konstanten sind oft leichter zu lesen als der Wert, der die Enum darstellt.

Erstellen einer Enum:

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

Dieses Beispiel aus dem Typoskript docs erklärt sehr schön , wie Aufzählungen arbeiten. Beachten Sie, dass unsere ersten ENUM - Wert (Up) mit 1. Alle folgenden Mitgliedern der Nummer Enum initialisiert werden dann automatisch erhöht von diesem Wert (dh nach unten = 2, links = 3, rechts = 4). Wenn wir nicht den ersten Wert mit 1 initialisiert haben würde der ENUM bei 0 beginnen und dann Autoinkrement (dh nach unten = 1, links = 2, rechts = 3).

Mit Hilfe eines ENUM:

Wir können die Werte der Enumeration auf folgende Weise 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 , wie wir unseren Code zu schreiben. Aufzählungen verhindern uns im Grunde verwendet magische Zahlen (Zahlen , die eine Einheit darstellen , da der Programmierer eine Bedeutung , die sie in einem bestimmten Kontext gegeben hat). Magische Zahlen sind schlecht , weil der folgenden Gründe:

1. Wir müssen denken, härter, müssen wir zuerst die Nummer zu einer Einheit übersetzen, bevor wir über unseren Code Vernunft kann.
2. Wenn wir unseren Code nach langer Zeit oder andere Programmierer überprüfen unseren Code zu überprüfen, sie nicht unbedingt wissen, was mit diesen Zahlen gemeint ist.