Cum de a crea enum ca tip dactilografiat?

Ca dactilografiate 0,9 (în prezent, o versiune alfa), puteți utiliza definiția enum ca aceasta:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

În mod implicit, aceste enumerările vor fi alocate 0, 1 și 2, respectiv. Dacă doriți să setați în mod explicit aceste numere, puteți face acest lucru, ca parte a declarației enum.

Listarea 6.2 Enumerări cu membrii explicite

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

var mySize = TShirtSize.Large;

Ambele aceste exemple ridicate direct din typescript pentru JavaScript programatori .

Rețineți că acest lucru este diferit de caietul de sarcini 0.8. Specificația 0.8 arata ca acest lucru - dar a fost marcat ca experimentale și probabil să se schimbe, așa că va trebui să actualizeze orice cod vechi:

Disclaimer - acest 0.8 exemplu ar fi rupt în versiuni mai noi ale compilatorului dactilografiate.

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

var mySize = TShirtSize.Large;

Aceasta este acum parte a limbii. A se vedea TypeScriptLang.org> Tipuri de bază> enum pentru documentația în acest sens. Un fragment din documentația cu privire la modul de utilizare a acestor enums:

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

Sau cu numere de suport manual:

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

Puteți merge , de asemenea , înapoi la numele enum prin utilizarea , de exemplu Color[2].

Iată un exemplu al modului în care totul merge împreună:

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

Acest lucru se va conecta:

undefined  
2  
Blue

Pentru că, la momentul scrierii acestui fapt, typescript Playground va genera acest cod:

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

Doar o altă notă că poți un enum id / string cu următorul text:

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


}

Actualizare :

După cum sa menționat de către @ iX3, dactilografiat 2.4 are suport pentru coarde enum.

A se vedea: Creați un enum cu valori string dactilografiat

Răspuns original:

Pentru valorile membre String, typescript permite doar numere ca valori membre ale enum. Dar există soluții câteva / hacks vă puteți pune în aplicare;

Soluția 1:

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

Există o soluție simplă: Doar aruncat șirul literal la orice înainte de a atribui:

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

soluție 2:

copiate din: https://basarat.gitbooks.io/typescript/content/docs/types/literal-types.html

Puteți folosi un șir literal ca un tip. De exemplu:

let foo: 'Hello';

Aici am creat o variabilă numită foo, care va permite numai valoarea literală „Bună ziua“, care urmează să fie atribuite. Acest lucru este demonstrat de mai jos:

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

Ele nu sunt foarte utile pe cont propriu, dar pot fi combinate într-o uniune de tip pentru a crea un puternic (și util) abstracție de exemplu:

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

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

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

Enums dactilografiat:

Enums sunt puse în limba dactilografiate pentru a defini un set de constante denumite. Utilizarea enums poate face viața mai ușoară. Motivul pentru aceasta este faptul că aceste constante sunt adesea mai ușor de citit decât valoarea care reprezintă enum.

Crearea unui enum:

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

Acest exemplu de la docs dactilografiat explică foarte bine modul în care funcționează enums. Observați că prima noastră valoare enum (Up) este inițializată cu 1. Toate următorii membri ai numărul enum sunt apoi automat incrementată de la această valoare ( de exemplu , în jos = 2, stânga = 3, dreapta = 4). Dacă nu am inițializa prima valoare cu 1 enum ar începe de la 0 și apoi automată creștere ( de exemplu , în jos = 1, stânga = 2, dreapta = 3).

Folosind un enum:

Putem accesa valorile enum în modul următor:

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

Observați că în acest fel suntem mult mai descriptiv în modul în care ne scrie codul nostru. Enums practic ne împiedică utilizarea numerelor magice (numere care reprezintă o entitate , deoarece programatorul a dat un sens pentru ei într - un anumit context). Numerele magice sunt rele din cauza următoarele motive:

1. Trebuie să ne gândim mai greu, trebuie mai întâi să traducă numărul la o entitate înainte de a putea rationa despre codul nostru.
2. Dacă vom examina codul nostru după un timp îndelungat sau alte programatori examina codul nostru, ei nu știu neapărat ce se înțelege cu aceste numere.