Cómo crear enumeración como el tipo a máquina de escribir?

A partir del texto mecanografiado 0.9 (actualmente una versión alpha), puede utilizar la definición de enumeración como esto:

enum TShirtSize {
  Small,
  Medium,
  Large
}

var mySize = TShirtSize.Large;

Por defecto, estas enumeraciones serán asignados 0, 1 y 2, respectivamente. Si desea establecer explícitamente estos números, puede hacerlo como parte de la declaración de enumeración.

6.2 Las enumeraciones lista con los miembros explícitos

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

var mySize = TShirtSize.Large;

Ambos ejemplos levantado directamente de mecanografiado para programadores de JavaScript .

Tenga en cuenta que esto es diferente a la especificación 0.8. La especificación 0.8 mirado como esto - pero fue marcado como experimental y pueden cambiar, por lo que tendrá que actualizar cualquier código antiguo:

Exención de responsabilidad - 0,8 este ejemplo se rompería en las últimas versiones del compilador mecanografiado.

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

var mySize = TShirtSize.Large;

Esto es ahora parte de la lengua. Ver TypeScriptLang.org>> Tipos básicos de enumeración para la documentación sobre este. Un extracto de la documentación sobre el uso de estas enumeraciones:

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

O con los números de respaldo manuales:

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

También puede ir de nuevo al nombre de enumeración utilizando, por ejemplo Color[2].

Aquí está un ejemplo de cómo todo esto va de la mano:

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

Debido a que, en el momento de escribir esto, la imprenta juegos 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();

Sólo otra nota que pueda una enumeración Identificación / cadena 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};


}

actualización :

Como se ha señalado por @ IX3, Letra de imprenta 2.4 tiene soporte para las cadenas de enumeración.

Ver: Crear una enumeración con valores de cadena a máquina de escribir

Respuesta original:

Para valores de los miembros de Cuerda, mecanografiado sólo permite números como valores de los miembros de enumeración. Sin embargo, hay pocas soluciones / hacks que se pueden implementar;

Solución 1:

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

Hay una solución simple: Sólo tire la cadena literal a cualquier antes de asignar:

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

Solución 2:

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

Se puede utilizar una cadena literal como un tipo. Por ejemplo:

let foo: 'Hello';

Aquí hemos creado una variable llamada foo que sólo permite el valor literal 'Hola' que se asignará a la misma. Esto se demuestra a continuación:

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

Ellos no son muy útiles por su cuenta, pero se pueden combinar en una unión de tipo para crear un poderoso (y útil) la abstracción por ejemplo:

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

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

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

Enumeraciones a máquina de escribir:

Las enumeraciones se ponen en el lenguaje mecanografiado para definir un conjunto de constantes con nombre. Utilizando las enumeraciones pueden hacer nuestra vida más fácil. La razón de esto es que estas constantes son a menudo más fácil de leer que el valor, que representa la enumeración.

Creación de una enumeración:

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

Este ejemplo de la documentación mecanografiado explica muy bien cómo funcionan las enumeraciones. Tenga en cuenta que el primer valor de enumeración (arriba) se inicializa con 1. Todos los siguientes miembros de la enumeración número son entonces automático incrementado de este valor (es decir, hacia abajo = 2, izquierda = 3, derecha = 4). Si no se ha inicializado el primer valor de la enumeración con 1 comenzaría a 0 y luego automático de incremento (es decir, hacia abajo = 1, izquierda = 2, derecha = 3).

El uso de 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;

Tenga en cuenta que de esta manera somos mucho más descriptiva en la forma de escribir nuestro código. Enumeraciones básicamente nos impiden el uso de números mágicos (números que representan alguna entidad debido a que el programador ha dado un significado para ellos en un determinado contexto). Números mágicos son malas debido a las siguientes razones:

1. Tenemos que pensar más, primero tenemos que traducir el número a una entidad antes de que podamos razonar acerca de nuestro código.
2. Si revisamos nuestro código después de un largo tiempo, o de otros programadores revisamos nuestro código, que no necesariamente saben lo que se quiere decir con estos números.