Wie erstelle ich einen aufzählungsähnlichen Typ in TypoSkript?

Question

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

Und ich muss eine Aufzählung wie Typ zB definieren. google.maps.Animation welches enthält zwei Eigenschaften: BOUNCE und DROP.

Wie soll das in TypoSkript gemacht werden?

Answer 1

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

enum AnimationType {
    BOUNCE,
    DROP,
}

Das letzte Komma ist optional.

Answer 2

Ab TypeScript 0.9 (derzeit eine Alpha-Version) können Sie die Aufzählungsdefinition wie folgt verwenden:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Standardmäßig werden diesen Aufzählungen 0, 1 und 2 zugewiesen.Wenn Sie diese Zahlen explizit festlegen möchten, können Sie dies als Teil 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 dem TypoSkript für JavaScript-Programmierer.

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

Haftungsausschluss - dieses 0.8-Beispiel wäre in neueren Versionen des TypeScript-Compilers fehlerhaft.

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

var mySize = TShirtSize.Large;

Answer 3

Das ist jetzt Teil der Sprache.Sehen TypeScriptLang.org > Grundtypen > enum für die Dokumentation dazu.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 Aufzählungsnamen zurückkehren, indem Sie zum Beispiel verwenden Color[2].

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

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

undefined  
2  
Blue

Weil der Typescript Playground zum Zeitpunkt des Schreibens diesen Code generiert:

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

Answer 4

Nur noch ein Hinweis, dass Sie eine ID / String-Aufzählung mit folgendem 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};


}

Answer 5

Update:

Wie von @iX3 bemerkt, Typoskript 2.4 hat Unterstützung für Aufzählungszeichenfolgen.

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

---

Ursprüngliche Antwort:

Bei Zeichenfolgenmemberwerten erlaubt TypeScript nur Zahlen als Aufzählungsmemberwerte.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:Wandeln Sie einfach das Zeichenfolgenliteral in any um, bevor Sie es 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, der nur der Literalwert 'Hello' zugewiesen werden kann.Dies wird unten demonstriert:

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

Sie sind allein nicht sehr nützlich, können aber in einer Typvereinigung kombiniert werden, um eine mächtige (und nützliche) Abstraktion zu erzeugen, z.:

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

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

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

Answer 6

Aufzählungen in Typoskript:

Aufzählungen werden in die Typescript-Sprache eingefügt, um eine Menge 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.

Erstellen einer Aufzählung:

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

Dieses Beispiel aus den Typescript-Dokumenten erklärt sehr gut, wie Aufzählungen funktionieren.Beachten Sie, dass unser erster Aufzählungswert (Up) mit 1 initialisiert wird.Alle folgenden Mitglieder der Zahlenaufzählung sind dann automatisch erhöht aus diesem Wert (d.h.Unten = 2, Links = 3, Rechts = 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.Unten = 1, Links = 2, Rechts = 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 wir auf diese Weise viel mehr sind beschreibenden in der Art, wie wir unseren Code schreiben.Aufzählungen hindern uns grundsätzlich daran, zu verwenden magische Zahlen (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 Nummer in eine Entität übersetzen, bevor wir über unseren Code nachdenken können.
2. Wenn wir unseren Code nach einer langen Weile überprüfen oder andere Programmierer unseren Code überprüfen, wissen sie nicht unbedingt, was mit diesen Zahlen gemeint ist.