Como criar um tipo semelhante a enum no TypeScript?

Question

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

E preciso definir um tipo enum como, por exemplo. google.maps.Animation que contém duas propriedades: BOUNCE e DROP.

Como isso deve ser feito no TypeScript?

Answer 1

TypeScript 0.9+ possui uma especificação para enums:

enum AnimationType {
    BOUNCE,
    DROP,
}

A vírgula final é opcional.

Answer 2

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 receberão 0, 1 e 2 respectivamente.Se quiser definir explicitamente esses números, você 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 para programadores JavaScript.

Observe que isso é diferente da especificação 0,8. A especificação 0.8 ficou assim - mas foi marcada como experimental e com probabilidade de mudar, então você terá que atualizar qualquer código antigo:

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

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

var mySize = TShirtSize.Large;

Answer 3

Isso agora faz parte da linguagem.Ver 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 funciona junto:

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 este artigo foi escrito, o Typescript Playground irá 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();

Answer 4

Apenas mais uma observação de que você pode usar um 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};


}

Answer 5

Atualizar:

Conforme observado por @iX3, Texto datilografado 2.4 tem suporte para strings enum.

Ver:Crie um enum com valores de string em Typescript

---

Resposta original:

Para valores de membros String, o TypeScript permite apenas números como valores de membros enum.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/

Há uma solução simples:Basta converter a string literal para any 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 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!

Answer 6

Enums em texto datilografado:

Enums são colocados na linguagem TypeScript para definir um conjunto de constantes nomeadas.Usar enums pode tornar nossa vida mais fácil.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 da documentação datilografada explica muito bem como as enumerações funcionam.Observe que nosso primeiro valor enum (Up) é inicializado com 1.Todos os seguintes membros do número enum são então incrementado automaticamente deste valor (ou seja,Baixo = 2, Esquerda = 3, Direita = 4).Se não inicializássemos o primeiro valor com 1, a enumeração começaria em 0 e depois incrementaria automaticamente (ou seja,Baixo = 1, Esquerda = 2, Direita = 3).

Usando uma enumeração:

Podemos acessar os valores do enum da seguinte maneira:

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

Observe que assim ficamos muito mais descritivo na maneira como escrevemos nosso código.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 traduzir o número para uma entidade antes de podermos 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 significa esses números.