Jak vytvořit výčet podobného typu na stroji?

Jak strojopisem 0,9 (v současné době uvolnění alpha) můžete použít definici výčtu takto:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Ve výchozím nastavení budou tyto výčty přidělí 0, 1 a 2, resp. Chcete-li explicitně nastavit tato čísla, můžete tak učinit v rámci prohlášení výčtu.

Výpis 6.2 výčty s explicitními členy

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

var mySize = TShirtSize.Large;

Oba tyto příklady zvedl přímo z strojopisem pro JavaScript programátory .

Všimněte si, že se liší od specifikace 0,8. Specifikace 0.8 vypadala takhle - ale to bylo označeno jako experimentální a pravděpodobně změní, takže budete muset aktualizovat všechny staré kód:

Disclaimer - tento 0.8 Příkladem by mohl být rozděleny v novějších verzích strojopisu kompilátor.

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

var mySize = TShirtSize.Large;

To je nyní součástí jazyka. Viz TypeScriptLang.org> Základní typy> ENUM pro dokumentaci na toto téma. Výňatek z dokumentace o tom, jak používat tyto výčty:

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

Nebo s manuálním doprovodné číslech:

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

Můžete se vrátit zpět k názvu výčtu pomocí např Color[2].

Zde je příklad toho, jak to všechno jde dohromady:

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

Tím se přihlásit:

undefined  
2  
Blue

Vzhledem k tomu, v době psaní tohoto, Typescript hřiště vygeneruje tento kód:

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

Just another note, kterou může id / Výčet řetězce s následující:

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


}

aktualizace :

Jak poznamenal @ iX3, Typescript 2,4 má podporu pro výčtu řetězců.

Viz: Vytvořte výčet provázkem hodnot na psacím stroji

Původní odpověď:

Pro členské hodnoty String, strojopisem umožňuje pouze čísla jako výčet členských hodnoty. Ale existuje několik řešení / hacky můžete realizovat;

Roztok 1:

zkopírován z: https://blog.rsuter.com/how-to-implement-an-enum-with-string-values-in-typescript/

K dispozici je jednoduché řešení: stačí házet řetězec doslovný některého před přiřazením:

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

Roztok 2:

zkopírován z: https://basarat.gitbooks.io/typescript/content/docs/types/literal-types.html

Můžete použít řetězec doslovný jako typ. Například:

let foo: 'Hello';

Zde jsme vytvořili proměnnou nazvanou foo, který umožní jen doslovný hodnotu ‚Hello‘, které mají být přiřazeny k tomu. Tento postup je znázorněn níže:

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

Jsou to velmi užitečné samy o sobě, ale mohou být kombinovány v typové unii vytvořit silný (a užitečný) abstrakce např:

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

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

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

Výčty na stroji:

Výčty jsou vloženy do jazyka strojopisu definovat množinu pojmenovaných konstant. Používání výčty může náš život jednodušší. Důvodem je to, že tyto konstanty jsou často čitelnější než hodnota kterém výčtu zastupuje.

Vytvoření výčet:

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

Tento příklad ze strojopisu dokumentů vysvětluje velmi dobře, jak výčty práce. Všimněte si, že náš první výčet hodnoty (Up) se inicializuje s 1. Všichni tito členové číslem výčtu jsou pak automaticky zvýšen z této hodnotě (Down = 2, Left = 3, vpravo = 4). Kdybychom neinicializoval první hodnoty s 1 ENUM by začínat na 0 ° C a pak se auto přírůstek (tj Down = 1, levá = 2, vpravo = 3).

Použití výčet:

Můžeme přístup k hodnotám výčtu následujícím způsobem:

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

Všimněte si, že tímto způsobem jsme mnohem popisná ve způsobu, jakým budeme psát náš kód. Výčty v podstatě nám brání pomocí čísel magické (čísla, která reprezentují určitou entitu, protože programátor dal smysl pro ně v určitém kontextu). Magická čísla jsou špatné, protože z následujících důvodů:

1. Musíme myslet tvrdší, musíme nejprve převést číslo subjektu, než budeme moci uvažovat o našem kódu.
2. Podíváme-li se náš kód po dlouhou dobu, nebo jiné programátory přečtení našeho kódu, ale nemusí nutně vědět, co je míněno s těmito čísly.