Jak utworzyć enum podobnego typu w maszynie?

Jak maszynopisu 0,9 (obecnie jest wersja alpha) można skorzystać z definicji enum tak:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Domyślnie te wyliczenia zostaną przypisane 0, 1 i 2 odpowiednio. Jeśli chcesz jawnie ustawić te numery, można to zrobić w ramach deklaracji enum.

Listing 6.2 wyliczeń z jawnych członków

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

var mySize = TShirtSize.Large;

Oba te przykłady podnoszone bezpośrednio z maszynopisu dla programistów JavaScript .

Należy zauważyć, że jest inaczej specyfikacji 0.8. Specyfikacja 0.8 wyglądał tak - ale został oznaczony jako eksperymentalny i może się zmienić, więc trzeba będzie zaktualizować każdy stary kod:

Zastrzeżenie - to 0,8 Przykładem może być uszkodzony w nowszych wersjach kompilatora maszynopis.

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

var mySize = TShirtSize.Large;

To jest teraz częścią języka. Zobacz TypeScriptLang.org>> Podstawowe typy enum dla dokumentacji na ten temat. Wyciąg z dokumentacji na temat korzystania z tych teksty stałe:

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

Z ręcznymi lub numerów podkładowych:

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

Możesz też wrócić do nazwy enum przy użyciu np Color[2].

Oto przykład tego, jak to wszystko idzie w parze:

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

Będzie to log:

undefined  
2  
Blue

Ponieważ w chwili pisania tego, Maszynopis zabaw wygeneruje ten kod:

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

Tylko kolejna uwaga, że ​​można enum id / string z następujących powodów:

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


}

aktualizacja :

Jak zauważył @ iX3, Maszynopis 2.4 posiada wsparcie dla ciągów enum.

Patrz: Tworzenie enum z ciągów znaków na maszynie

Odpowiedź oryginalny:

Dla wartości członkowskich Smyczkowych, maszynopis pozwala tylko liczby jako wartości członkowskich enum. Ale istnieje kilka rozwiązań / hacki można wdrożyć;

Rozwiązanie 1:

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

Jest to proste rozwiązanie: wystarczy rzucić ciąg dosłownego któregokolwiek przed przypisaniem:

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

Roztwór 2:

skopiowane z: https://basarat.gitbooks.io/typescript/content/docs/types/literal-types.html

Można użyć ciągu literalnego jako typ. Na przykład:

let foo: 'Hello';

Tutaj stworzyliśmy zmienną o nazwie foo, który pozwoli tylko wartość dosłowne „Hello”, aby przypisać do niego. Dowodem na to jest poniżej:

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

Nie są one bardzo przydatne, na własną rękę, ale mogą być łączone w celu utworzenia unii typu potężny (i przydatne) abstrakcji, np:

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

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

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

Wyliczenia w maszynopisie:

Teksty stałe są umieszczane w języku maszynopis do określenia zbioru nazwanych stałych. Korzystanie teksty stałe mogą uczynić nasze życie łatwiejszym. Powodem tego jest to, że te stałe są często łatwiejsze do odczytania niż wartość, która reprezentuje enum.

Tworzenie enum:

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

Ten przykład z docs maszynopis wyjaśnia, w jaki sposób działa bardzo ładnie teksty stałe. Zauważ, że nasza pierwsza wartość enum (Up) jest inicjowany z 1. Wszystkie następujących członków numerem wyliczenia są następnie automatycznie zwiększane od tej wartości (tj dół = 2, Left = 3, prawo = 4). Jeśli nie zainicjować pierwszą wartość z 1 enum ruszy na 0, a następnie auto przyrost (tj dół = 1, lewa = 2, prawo = 3).

Korzystanie z wyliczenia:

Możemy uzyskać dostęp do wartości wyliczenia w następujący sposób:

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

Zauważ, że w ten sposób jesteśmy o wiele bardziej opisowy w sposób piszemy nasz kod. Wyliczenia w zasadzie uniemożliwiają nam za pomocą liczb magicznych (numery, które stanowią jedne podmiot ponieważ programista dał znaczenie dla nich w pewnym kontekście). Liczby magiczne są złe z powodu następujących powodów:

1. Musimy myśleć trudniejsze, najpierw musimy tłumaczyć numer do jednostki przed możemy rozumować o naszym kodzie.
2. Jeśli przeanalizujemy nasz kod po długim czasie, lub innych programistów przeglądu naszego kodu, oni nie muszą wiedzieć, co rozumie się z tych liczb.