¿Cómo crear una enumeración como tipo en TypeScript?

Estoy trabajando en un archivo de definiciones para la API de mapas de Google para TypeScript.

Y necesito definir una enumeración como tipo, por ejemplo. google.maps.Animationque contiene dos propiedades: BOUNCEy DROP.

¿Cómo se debe hacer esto en TypeScript?

TypeScript 0.9+ tiene una especificación para enumeraciones:

enum AnimationType {
    BOUNCE,
    DROP,
}

La coma final es opcional.

A partir de TypeScript 0.9 (actualmente una versión alfa), puede usar la definición de enumeración como esta:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

De forma predeterminada, a estas enumeraciones se les asignará 0, 1 y 2 respectivamente. Si desea establecer explícitamente estos números, puede hacerlo como parte de la declaración enum.

Listado 6.2 Enumeraciones con miembros explícitos

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

var mySize = TShirtSize.Large;

Ambos ejemplos se sacaron directamente de TypeScript para programadores de JavaScript .

Tenga en cuenta que esto es diferente a la especificación 0.8. La especificación 0.8 se veía así, pero estaba marcada como experimental y es probable que cambie, por lo que tendrá que actualizar cualquier código anterior:

Descargo de responsabilidad : este ejemplo 0.8 se rompería en versiones más recientes del compilador de TypeScript.

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

var mySize = TShirtSize.Large;

Esto ahora es parte del lenguaje. Consulte TypeScriptLang.org> Tipos básicos> enumeración para obtener la documentación sobre esto. Un extracto de la documentación sobre cómo usar estas enumeraciones:

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

O con números de respaldo manuales:

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

También puede volver al nombre de la enumeración usando, por ejemplo Color[2] .

Aquí hay un ejemplo de cómo va todo 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();

Esto registrará:

undefined  
2  
Blue

Porque, en el momento de escribir esto, el Typecript Playground generará 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();

Solo otra nota de que puede hacer una enumeración de id / string con lo siguiente:

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


}

Actualizar :

Como señaló @ iX3, Typecript 2.4 tiene soporte para cadenas de enumeración.

Ver: Crear una enumeración con valores de cadena en Typecript

Respuesta original:

Para los valores de miembro de cadena, TypeScript solo permite números como valores de miembro de enumeración. Pero hay algunas soluciones / trucos que puede implementar;

Solución 1:

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

Hay una solución simple: simplemente transmita la cadena literal a cualquiera antes de asignar:

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

solución 2:

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

Puede utilizar un literal de cadena como tipo. Por ejemplo:

let foo: 'Hello';

Aquí hemos creado una variable llamada foo que solo permitirá que se le asigne el valor literal 'Hola'. Esto se demuestra a continuación:

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

No son muy útiles por sí solos, pero se pueden combinar en una unión de tipos para crear una abstracción poderosa (y útil), por ejemplo:

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

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

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

Enums en mecanografiado:

Las enumeraciones se colocan en el lenguaje mecanografiado para definir un conjunto de constantes con nombre. Usar enumeraciones puede hacernos la vida más fácil. La razón de esto es que estas constantes suelen ser más fáciles de leer que el valor que representa la enumeración.

Creando una enumeración:

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

Este ejemplo de los documentos mecanografiados explica muy bien cómo funcionan las enumeraciones. Observe que nuestro primer valor de enumeración (Up) se inicializa con 1. Todos los siguientes miembros de la enumeración numérica se incrementan automáticamente partir de este valor (es decir, Abajo = 2, Izquierda = 3, Derecha = 4). Si no inicializamos el primer valor con 1, la enumeración comenzaría en 0 y luego se incrementaría automáticamente (es decir, Abajo = 1, Izquierda = 2, Derecha = 3).

Usando una enumeración:

Podemos acceder a los valores de la enumeración de la siguiente manera:

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

Observe que de esta manera somos mucho más descriptivos en la forma en que escribimos nuestro código. Las enumeraciones básicamente nos impiden usar números mágicos (números que representan alguna entidad porque el programador les ha dado un significado en un contexto determinado). Los números mágicos son malos por las siguientes razones:

1. Tenemos que pensar más, primero tenemos que traducir el número a una entidad antes de poder razonar sobre nuestro código.
2. Si revisamos nuestro código después de un largo tiempo, o si otros programadores revisan nuestro código, no necesariamente saben lo que significan estos números.