Hoe te enum zoals het type met de schrijfmachine te creëren?

Met ingang van getypte 0,9 (momenteel een alpha release) kunt u de enum definitie als volgt te gebruiken:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Standaard wordt deze tellingen respectievelijk toegewezen 0, 1 en 2. Wilt u expliciet deze nummers, kunt u dat doen in het kader van de enum verklaring.

Listing 6.2 Opsommingen met expliciete leden

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

var mySize = TShirtSize.Large;

Beide voorbeelden getild direct uit typoscript voor JavaScript-programmeurs .

Merk op dat dit verschilt van de 0.8 specificatie. De 0.8-specificatie zag er als volgt - maar het is gemarkeerd als experimenteel en waarschijnlijk veranderen, dus je zult moeten alle oude code bij te werken:

Disclaimer - dit 0,8 voorbeeld zou worden opgesplitst in nieuwere versies van het typoscript compiler.

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

var mySize = TShirtSize.Large;

Dit is nu onderdeel van de taal. Zie TypeScriptLang.org> basistypen> enum voor de documentatie over dit. Een uittreksel van de documentatie over hoe deze opsommingen te gebruiken:

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

Of met handmatige steun nummers:

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

U kunt ook terug naar de naam enum gaan door gebruik te maken bijvoorbeeld Color[2].

Hier is een voorbeeld van hoe dit hoort allemaal bij elkaar:

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

Dit zal log:

undefined  
2  
Blue

Want op het moment van schrijven van dit, zal de Typescript Playground deze code te genereren:

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

Gewoon weer een notitie die u kunt een id / tekenreeksopsomming met het volgende:

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


}

update :

Zoals opgemerkt door @ iX3, Typescript 2.4 heeft ondersteuning voor enum strings.

Zie ook: Maak een enum met string waarden in Typescript

Oorspronkelijke antwoord:

Voor String lid waarden, typoscript laat alleen nummers als enum lid waarden. Maar er zijn een paar oplossingen / hacks die u kunt implementeren;

Oplossing 1:

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

Er is een eenvoudige oplossing: Gewoon wierp het letterlijke tekenreeks om eventuele vóór het toewijzen:

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

Oplossing 2:

gekopieerd uit: https://basarat.gitbooks.io/typescript/content/docs/types/literal-types.html

U kunt een letterlijke tekenreeks als een type te gebruiken. Bijvoorbeeld:

let foo: 'Hello';

Hier hebben we een variabele met de naam foo dat alleen zal de letterlijke waarde 'Hello' te worden toegewezen aan het creëerde. Dit wordt hieronder aangetoond:

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

Ze zijn niet erg nuttig op hun eigen, maar kunnen worden gecombineerd in een soort vakbond om een ​​krachtige (en nuttige) abstractie bijvoorbeeld te maken:

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

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

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

Opsommingen in typoscript:

Opsommingen zijn in de typoscript taal te maken aan een reeks genaamd constanten definiëren. Met behulp van opsommingen kunnen ons leven te vergemakkelijken. De reden hiervoor is dat deze constanten zijn vaak makkelijker te lezen dan de waarde die de enum vertegenwoordigt.

Een opsomming:

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

Dit voorbeeld van het typoscript docs legt uit heel mooi zien hoe enums werken. Merk op dat onze eerste enum-waarde (Up) wordt geïnitialiseerd met 1. Alle volgende leden van het aantal enum worden dan automatisch verhoogd van deze waarde (nl omlaag = 2, Links = 3, rechts = 4). Als we niet de eerste waarde heeft initialiseren met 1 de enum zou beginnen bij 0 en dan automatisch increment (ie omlaag = 1, Links = 2, rechts = 3).

Met behulp van een enum:

We kunnen toegang krijgen tot de waarden van de enum op de volgende manier:

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

Merk op dat op deze manier zijn we veel meer beschrijvend in de manier waarop we schrijven onze code. Enumeraties eigenlijk voorkomen dat we met behulp van magische getallen (nummers die enkele entiteit worden beschouwd, omdat de programmeur een betekenis om ze in een bepaalde context heeft gegeven). Magische getallen zijn slecht vanwege de volgende redenen:

1. We moeten harder te denken, moeten we eerst het aantal te vertalen naar een entiteit voordat we kunnen redeneren over onze code.
2. Als we onze code te herzien na een lange tijd, of andere programmeurs Lees onze code, doen ze niet per se weten wat er bedoeld wordt met deze nummers.