Как создать перечисление как типа в машинописном?

По состоянию на машинопись 0.9 (в настоящее время альфа-релиз), вы можете использовать определение перечисления так:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

По умолчанию этих перечисления будут присвоены 0, 1 и 2 соответственно. Если вы хотите явно установить эти цифры, вы можете сделать это в рамках декларации перечислений.

Листинг 6.2 Перечни с явными членами

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

var mySize = TShirtSize.Large;

Оба этих примера сняты непосредственно из Машинопись для JavaScript программистов .

Обратите внимание , что это отличается от 0.8 спецификации. Спецификация 0,8 Выглядело это - но он был отмечен как экспериментальный и , вероятно, изменится, так что вам придется обновлять любой старый код:

Отказ от ответственности - это 0,8 Примером может быть разорван в более новых версиях машинописи компилятора.

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

var mySize = TShirtSize.Large;

Это является частью языка. См TypeScriptLang.org> Основные типы> перечисление для документации по этому вопросу . Выдержка из документации о том , как использовать эти перечисления:

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

Или с ручными номерами отступающих:

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

Вы также можете вернуться к имени перечислений, используя, например Color[2].

Вот пример того, как все это идет вместе:

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

Это будет регистрировать:

undefined  
2  
Blue

Потому что, на момент написания этого Машинопись площадка будет генерировать этот код:

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

Просто еще обратите внимание, что вы можете A ID / строка перечисление со следующим:

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


}

Обновление :

Как отметил @ ix3, Машинопись 2,4 имеет поддержку перечислений строк.

См: Создать перечисление со значениями строк в машинописном

Оригинальный ответ:

Для значений членов Струнных, машинопись позволяет только цифры в качестве значений членов перечисления. Но есть несколько решений / хаков можно реализовать;

Решение 1:

скопировано с: https://blog.rsuter.com/how-to-implement-an-enum-with-string-values-in-typescript/

Существует простое решение: Просто бросить строковый литерал любого перед назначением:

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

Раствор 2:

скопировано с: https://basarat.gitbooks.io/typescript/content/docs/types/literal-types.html

Вы можете использовать строковой литерал как тип. Например:

let foo: 'Hello';

Здесь мы создали переменную с именем Foo, который только позволит буквальное значение «Hello», чтобы быть возложены на него. Это показано ниже:

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

Они не очень полезны сами по себе, но могут быть объединены в типе объединения, чтобы создать мощный (и полезный) абстракции, например:

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

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

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

Перечисления в машинописи:

Перечисления ставятся на язык машинописи, чтобы определить набор именованных констант. Использование перечисления могут сделать нашу жизнь проще. Причина этого заключается в том, что эти константы часто легче читать, чем значение, которое представляет перечисление.

Создание перечисления:

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

Этот пример из машинописи документации объясняет очень хорошо , как работают перечисления. Обратите внимание , что наше первое значение перечисления (Up) инициализируются 1. Всеми следующими членами номера перечисления затем автоматически увеличивается от этого значения (то есть вниз = 2, Left = 3, вправо = 4). Если бы мы не инициализировать первое значение с 1 перечисление будет начинаться с 0 , а затем автоматическое приращение (т.е. вниз = 1, Left = 2, Right = 3).

Использование перечисления:

Мы можем получить доступ к значениям перечисления следующим образом:

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

Обратите внимание на то, что таким образом мы гораздо более описательный , как мы напишем наш код. Перечисления в основном мешают нам использовать магические константы (числа , которые представляют собой некоторую сущность , потому что программист дал значение для них в определенном контексте). Магические числа плохо из - за следующих причин:

1. Нам нужно думать труднее, нам сначала нужно перевести число в сущности, прежде чем мы можем рассуждать о нашем коде.
2. Если мы рассмотрим наш код после того, как долгое время, или другие программисты просматривать наш код, они не обязательно знать, что имеется в виду под этими номерами.