Как создать тип типа enum в TypeScript?

Я работаю над файлом определений для API карт Google для TypeScript.

И мне нужно определить тип типа enum, например. google.maps.Animationкоторый содержит два свойства: BOUNCEи DROP.

Как это сделать в TypeScript?

TypeScript 0.9+ имеет спецификацию перечислений:

enum AnimationType {
    BOUNCE,
    DROP,
}

Последняя запятая не обязательна.

Начиная с TypeScript 0.9 (в настоящее время это альфа-версия) вы можете использовать определение перечисления следующим образом:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

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

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

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

var mySize = TShirtSize.Large;

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

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

Заявление об отказе от ответственности - этот пример 0.8 будет нарушен в более новых версиях компилятора TypeScript.

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

Потому что на момент написания этого кода Typescript Playground сгенерирует этот код:

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

Еще одно замечание, что вы можете перечислить идентификатор / строку со следующим:

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


}

Обновление :

Как отмечает @ iX3, Typescript 2.4 поддерживает строки перечисления.

См .: Создание перечисления со строковыми значениями в Typescript

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

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

Решение 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. Все следующие элементы числового перечисления затем автоматически увеличиваются. с этого значения (то есть Down = 2, Left = 3, Right = 4). Если бы мы не инициализировали первое значение с 1, перечисление началось бы с 0, а затем автоматически увеличилось бы (т.е. Down = 1, Left = 2, Right = 3).

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

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

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

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

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