Como criar enum como tipo no TypeScript?

Estou trabalhando em um arquivo de definições para a API de mapas do Google para TypeScript.

E eu preciso definir um enum como tipo por exemplo. google.maps.Animationque contém duas propriedades: BOUNCEe DROP.

Como isso deve ser feito no TypeScript?

O TypeScript 0.9+ tem uma especificação para enumerações:

enum AnimationType {
    BOUNCE,
    DROP,
}

A vírgula final é opcional.

A partir do TypeScript 0.9 (atualmente uma versão alfa), você pode usar a definição de enum assim:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Por padrão, essas enumerações serão atribuídas 0, 1 e 2, respectivamente. Se você deseja definir explicitamente esses números, pode fazê-lo como parte da declaração enum.

Listagem 6.2 Enumerações com membros explícitos

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

var mySize = TShirtSize.Large;

Ambos os exemplos foram retirados diretamente do TypeScript for JavaScript Programmers .

Observe que isso é diferente da especificação 0.8. A especificação 0.8 tinha a seguinte aparência - mas estava marcada como experimental e com possibilidade de alteração, portanto, você precisará atualizar qualquer código antigo:

Isenção de responsabilidade - este exemplo 0.8 seria quebrado nas versões mais recentes do compilador TypeScript.

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

var mySize = TShirtSize.Large;

Isso agora faz parte do idioma. Consulte TypeScriptLang.org> Tipos básicos> enum para obter a documentação sobre isso. Um trecho da documentação sobre como usar essas enumerações:

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

Ou com números de apoio manuais:

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

Você também pode voltar ao nome da enumeração usando, por exemplo Color[2].

Aqui está um exemplo de como tudo isso acontece:

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

Isso registrará:

undefined  
2  
Blue

Porque, no momento em que escrevemos isso, o Typcript Playground gerará este código:

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

Apenas mais uma observação de que você pode enum de id / string com o seguinte:

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


}

Atualização :

Conforme observado por @ iX3, o Typescript 2.4 tem suporte para seqüências de caracteres enum.

Consulte: Criar uma enumeração com valores de sequência em TypeScript

Resposta original:

Para valores de membro de String, o TypeScript permite apenas números como valores de membro de enumeração. Mas existem algumas soluções / hacks que você pode implementar;

Solução 1:

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

Existe uma solução simples: basta converter a string literal em qualquer uma antes de atribuir:

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

solução 2:

copiado de: https://basarat.gitbooks.io/typescript/content/docs/types/literal-types.html

Você pode usar uma string literal como um tipo. Por exemplo:

let foo: 'Hello';

Aqui, criamos uma variável chamada foo que permitirá apenas que o valor literal 'Hello' seja atribuído a ela. Isso é demonstrado abaixo:

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

Eles não são muito úteis por si só, mas podem ser combinados em uma união de tipos para criar uma abstração poderosa (e útil), por exemplo:

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

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

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

Enums em texto datilografado:

As enumerações são colocadas na linguagem de texto para definir um conjunto de constantes nomeadas. Usar enums pode facilitar nossa vida. A razão para isso é que essas constantes geralmente são mais fáceis de ler do que o valor que o enum representa.

Criando uma enumeração:

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

Este exemplo dos documentos datilografados explica muito bem como as enums funcionam. Observe que nosso primeiro valor de enum (Para cima) é inicializado com 1. Todos os seguintes membros do número de enum são então incrementados automaticamente a partir desse valor (ou seja, Baixo = 2, Esquerda = 3, Direita = 4). Se não inicializarmos o primeiro valor com 1, a enumeração começará em 0 e, em seguida, aumentará automaticamente (ou seja, Baixo = 1, Esquerda = 2, Direita = 3).

Usando uma enumeração:

Podemos acessar os valores da enumeração da seguinte maneira:

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

Observe que desta forma somos muito mais descritivos na maneira como escrevemos nosso código. As enums basicamente nos impedem de usar números mágicos (números que representam alguma entidade porque o programador lhes deu um significado em um determinado contexto). Os números mágicos são ruins pelos seguintes motivos:

1. Precisamos pensar mais, primeiro precisamos converter o número para uma entidade antes que possamos raciocinar sobre nosso código.
2. Se revisarmos nosso código depois de um longo tempo, ou outros programadores revisarem nosso código, eles não saberão necessariamente o que se entende com esses números.