example - typescript version

Crear una enumeración con valores de cadena

Question

El siguiente código se puede usar para crear una enum en TypeScript:

enum e {
    hello = 1,
    world = 2
};

Y se puede acceder a los valores por:

e.hello;
e.world;

¿Cómo creo una enum con valores de cadena?

enum e {
    hello = "hello", // error: cannot convert string to e
    world = "world"  // error 
};

Answer 1

TypeScript 2.4

Ahora tiene una lista de cadenas, así que tu código simplemente funciona:

enum E {
    hello = "hello",
    world = "world"
};

🌹

TypeScript 1.8

Desde TypeScript 1.8, puede usar tipos literales de cadena para proporcionar una experiencia confiable y segura para los valores de cadena nombrados (que es en parte para lo que se usan las enumeraciones).

type Options = "hello" | "world";
var foo: Options;
foo = "hello"; // Okay 
foo = "asdf"; // Error!

Más: https://www.typescriptlang.org/docs/handbook/advanced-types.html#string-literal-types

Soporte legado

Las enumeraciones en TypeScript están basadas en números.

Puedes usar una clase con miembros estáticos aunque:

class E
{
    static hello = "hello";
    static world = "world"; 
}

Podrías ir claro también:

var E = {
    hello: "hello",
    world: "world"
}

Actualización: Basado en el requisito de poder hacer algo como var test:E = E.hello; lo siguiente satisface esto:

class E
{
    // boilerplate 
    constructor(public value:string){    
    }

    toString(){
        return this.value;
    }

    // values 
    static hello = new E("hello");
    static world = new E("world");
}

// Sample usage: 
var first:E = E.hello;
var second:E = E.world;
var third:E = E.hello;

console.log("First value is: "+ first);
console.log(first===third); 

Answer 2

TypeScript 2.1 +

Los tipos de búsqueda , introducidos en TypeScript 2.1 permiten otro patrón para simular enums de cadena:

// String enums in TypeScript 2.1
const EntityType = {
    Foo: ''Foo'' as ''Foo'',
    Bar: ''Bar'' as ''Bar''
};

function doIt(entity: keyof typeof EntityType) {
    // ...
}

EntityType.Foo          // ''Foo''
doIt(EntityType.Foo);   // 👍
doIt(EntityType.Bar);   // 👍
doIt(''Foo'');            // 👍
doIt(''Bad'');            // 🙁 

TypeScript 2.4 +

Con la versión 2.4, TypeScript introdujo soporte nativo para enums de cadena, por lo que la solución anterior no es necesaria. De los documentos TS:

enum Colors {
  Red = "RED",
  Green = "GREEN",
  Blue = "BLUE",
}

Answer 3

¿Por qué no usar la forma nativa de acceder a las cadenas de una enumeración?

enum e {
  WHY,
  NOT,
  USE,
  NATIVE
}

e[e.WHY] // this returns string ''WHY''

Answer 4

Acabo de declarar una interfaz y uso una variable de ese tipo para acceder a la enumeración. Mantener la interfaz y la enumeración en sincronía es realmente fácil, ya que TypeScript se queja si algo cambia en la enumeración, como tal.

error TS2345: El argumento del tipo ''typeof EAbFlagEnum'' no se puede asignar al parámetro de tipo ''IAbFlagEnum''. Falta la propiedad ''Mover'' en el tipo ''tipo de EAbFlagEnum''.

La ventaja de este método es que no se requiere conversión de tipo para utilizar la enumeración (interfaz) en diversas situaciones, por lo que se admiten más tipos de situaciones, como el conmutador / caja.

// Declare a TypeScript enum using unique string 
//  (per hack mentioned by zjc0816)

enum EAbFlagEnum {
  None      = <any> "none",
  Select    = <any> "sel",
  Move      = <any> "mov",
  Edit      = <any> "edit",
  Sort      = <any> "sort",
  Clone     = <any> "clone"
}

// Create an interface that shadows the enum
//   and asserts that members are a type of any

interface IAbFlagEnum {
    None:   any;
    Select: any;
    Move:   any;
    Edit:   any;
    Sort:   any;
    Clone:  any;
}

// Export a variable of type interface that points to the enum

export var AbFlagEnum: IAbFlagEnum = EAbFlagEnum;

El uso de la variable, en lugar de la enumeración, produce los resultados deseados.

var strVal: string = AbFlagEnum.Edit;

switch (strVal) {
  case AbFlagEnum.Edit:
    break;
  case AbFlagEnum.Move:
    break;
  case AbFlagEnum.Clone
}

Las banderas eran otra necesidad para mí, así que creé un módulo NPM que se agrega a este ejemplo e incluye pruebas.

https://github.com/djabraham/ts-enum-tools

Answer 5

Aquí hay una solución bastante limpia que permite la herencia, utilizando TypeScript 2.0. No probé esto en una versión anterior.

Bonus: el valor puede ser de cualquier tipo!

export class Enum<T> {
  public constructor(public readonly value: T) {}
  public toString() {
    return this.value.toString();
  }
}

export class PrimaryColor extends Enum<string> {
  public static readonly Red = new Enum(''#FF0000'');
  public static readonly Green = new Enum(''#00FF00'');
  public static readonly Blue = new Enum(''#0000FF'');
}

export class Color extends PrimaryColor {
  public static readonly White = new Enum(''#FFFFFF'');
  public static readonly Black = new Enum(''#000000'');
}

// Usage:

console.log(PrimaryColor.Red);
// Output: Enum { value: ''#FF0000'' }
console.log(Color.Red); // inherited!
// Output: Enum { value: ''#FF0000'' }
console.log(Color.Red.value); // we have to call .value to get the value.
// Output: #FF0000
console.log(Color.Red.toString()); // toString() works too.
// Output: #FF0000

class Thing {
  color: Color;
}

let thing: Thing = {
  color: Color.Red,
};

switch (thing.color) {
  case Color.Red: // ...
  case Color.White: // ...
}

Answer 6

Con los transformadores personalizados ( https://github.com/Microsoft/TypeScript/pull/13940 ) que está disponible en mecanografiado @ siguiente, puede crear una enumeración como un objeto con valores de cadena de tipos literales de cadena.

Por favor mire en mi paquete npm, ts-transformer-enumerate .

Ejemplo de uso:

// The signature of `enumerate` here is `function enumerate<T extends string>(): { [K in T]: K };`
import { enumerate } from ''ts-transformer-enumerate'';

type Colors = ''green'' | ''yellow'' | ''red'';
const Colors = enumerate<Colors>();

console.log(Colors.green); // ''green''
console.log(Colors.yellow); // ''yellow''
console.log(Colors.red); // ''red''

Answer 7

Creo que deberías intentar con esto, en este caso el valor de la variable no cambiará y funciona como enums, usando como una clase también funciona, la única desventaja es que por error puedes cambiar el valor de la variable estática y eso es lo que No queremos en las enumeraciones.

namespace portal {

export namespace storageNames {

    export const appRegistration = ''appRegistration'';
    export const accessToken = ''access_token'';

  }
}

Answer 8

En TypeScript 0.9.0.1, aunque se produce un error de compilación, el compilador todavía puede compilar el archivo ts en el archivo js. El código funciona como esperábamos y Visual Studio 2012 puede admitir la finalización automática del código.

Actualización:

En sintaxis, TypeScript no nos permite crear una enumeración con valores de cadena, pero podemos hackear el compilador: p

enum Link
{
    LEARN   =   <any>''/Tutorial'',
    PLAY    =   <any>''/Playground'',
    GET_IT  =   <any>''/#Download'',
    RUN_IT  =   <any>''/Samples'',
    JOIN_IN =   <any>''/#Community''
}

alert(''Link.LEARN:    ''                     + Link.LEARN);
alert(''Link.PLAY:    ''                      + Link.PLAY);
alert(''Link.GET_IT:    ''                    + Link.GET_IT);
alert(''Link[/'/Samples/']:    Link.''        + Link[''/Samples'']);
alert(''Link[/'/#Community/']    Link.''      + Link[''/#Community'']);

Playground

Answer 9

En la última versión (1.0RC) de TypeScript, puede utilizar enumeraciones como esta:

enum States {
    New,
    Active,
    Disabled
} 

// this will show message ''0'' which is number representation of enum member
alert(States.Active); 

// this will show message ''Disabled'' as string representation of enum member
alert(States[States.Disabled]);

Actualización 1

Para obtener el valor numérico del miembro de enumeración del valor de cadena, puede usar esto:

var str = "Active";
// this will show message ''1''
alert(States[str]);

Actualización 2

En la última versión de TypeScript 2.4, se introdujeron enums de cadena, como este:

enum ActionType {
    AddUser = "ADD_USER",
    DeleteUser = "DELETE_USER",
    RenameUser = "RENAME_USER",

    // Aliases
    RemoveUser = DeleteUser,
}

Para obtener más información sobre TypeScript 2.4, lea el blog en MSDN .

Answer 10

Enfrenté este problema recientemente con TypeScript 1.0.1 y lo resolví de esta manera:

enum IEvents {
        /** A click on a product or product link for one or more products. */
        CLICK,
        /** A view of product details. */
        DETAIL,
        /** Adding one or more products to a shopping cart. */
        ADD,
        /** Remove one or more products from a shopping cart. */
        REMOVE,
        /** Initiating the checkout process for one or more products. */
        CHECKOUT,
        /** Sending the option value for a given checkout step. */
        CHECKOUT_OPTION,
        /** The sale of one or more products. */
        PURCHASE,
        /** The refund of one or more products. */
        REFUND,
        /** A click on an internal promotion. */
        PROMO_CLICK
}

var Events = [
        ''click'',
        ''detail'',
        ''add'',
        ''remove'',
        ''checkout'',
        ''checkout_option'',
        ''purchase'',
        ''refund'',
        ''promo_click''
];

function stuff(event: IEvents):boolean {
        // event can now be only IEvents constants
        Events[event]; // event is actually a number that matches the index of the array
}
// stuff(''click'') won''t work, it needs to be called using stuff(IEvents.CLICK)

Answer 11

Enum muy, muy, muy simple con cadena (TypeScript 2.4)

import * from ''../mylib''

export enum MESSAGES {
    ERROR_CHART_UNKNOWN,
    ERROR_2
}

export class Messages {
    public static get(id : MESSAGES){
        let message = ""
        switch (id) {
            case MESSAGES.ERROR_CHART_UNKNOWN :
                message = "The chart does not exist."
                break;
            case MESSAGES.ERROR_2 :
                message = "example."
                break;
        }
        return message
    }
}

function log(messageName:MESSAGES){
    console.log(Messages.get(messageName))
}

Answer 12

Estaba buscando una forma de implementar descripciones en enumeraciones mecanografiadas (v2.5) y este patrón funcionó para mí:

export enum PriceTypes {
    Undefined = 0,
    UndefinedDescription = ''Undefined'' as any,
    UserEntered = 1,
    UserEnteredDescription = ''User Entered'' as any,
    GeneratedFromTrade = 2,
    GeneratedFromTradeDescription = ''Generated From Trade'' as any,
    GeneratedFromFreeze = 3,
    GeneratedFromFreezeDescription = ''Generated Rom Freeze'' as any
}

...

    GetDescription(e: any, id: number): string {
        return e[e[id].toString() + "Description"];
    }
    getPriceTypeDescription(price: IPricePoint): string {
        return this.GetDescription(PriceTypes, price.priceType);
    }

Answer 13

Esto funciona para mí:

class MyClass {
    static MyEnum: { Value1; Value2; Value3; }
    = {
        Value1: "Value1",
        Value2: "Value2",
        Value3: "Value3"
    };
}

o

module MyModule {
    export var MyEnum: { Value1; Value2; Value3; }
    = {
        Value1: "Value1",
        Value2: "Value2",
        Value3: "Value3"
    };
}

8)

Actualización: Poco después de publicar esto, descubrí otra forma, pero olvidé publicar una actualización (sin embargo, alguien ya lo mencionó anteriormente):

enum MyEnum {
    value1 = <any>"value1 ", 
    value2 = <any>"value2 ", 
    value3 = <any>"value3 " 
}

Answer 14

Hay muchas respuestas, pero no veo ninguna solución completa. El problema con la respuesta aceptada, así como con la enum { this, one } , es que dispersa el valor de cadena que está usando a través de muchos archivos. Tampoco me gusta la "actualización", es complejo y no aprovecha los tipos también. Creo que la respuesta de Michael Bromley es la más correcta, pero su interfaz es un poco complicada y podría hacer con un tipo.

Estoy usando TypeScript 2.0. * Esto es lo que haría

export type Greeting = "hello" | "world";
export const Greeting : { hello: Greeting , world: Greeting } = {
    hello: "hello",
    world: "world"
};

let greet: Greeting = Greeting.hello

También tiene una información mucho más agradable de tipo / desplazamiento al usar un IDE útil. La desventaja es que tienes que escribir las cadenas dos veces, pero al menos solo en dos lugares.

Answer 15

He intentado en TypeScript 1.5 como a continuación y ha funcionado para mí

module App.Constants {
   export enum e{
        Hello= ("Hello") as any,
World= ("World") as any
    }
}

Answer 16

La respuesta de @ basarat fue genial. Aquí está simplificado pero un poco extenso ejemplo puede usar:

export type TMyEnumType = ''value1''|''value2'';

export class MyEnumType {
    static VALUE1: TMyEnumType = ''value1'';
    static VALUE2: TMyEnumType = ''value2'';
}

console.log(MyEnumType.VALUE1); // ''value1''

const variable = MyEnumType.VALUE2; // it has the string value ''value2''

switch (variable) {
    case MyEnumType.VALUE1:
        // code...

    case MyEnumType.VALUE2:
        // code...
}

Answer 17

Little js-hacky pero funciona: e[String(e.hello)]

Answer 18

Puedes usar enums de cadena en el último TypeScript:

enum e
{
    hello = <any>"hello",
    world = <any>"world"
};

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

ACTUALIZACIÓN - 2016

Una forma ligeramente más sólida de hacer un conjunto de cadenas que uso para React en estos días es la siguiente:

export class Messages
{
    static CouldNotValidateRequest: string = ''There was an error validating the request'';
    static PasswordMustNotBeBlank: string = ''Password must not be blank'';   
}

import {Messages as msg} from ''../core/messages'';
console.log(msg.PasswordMustNotBeBlank);

Answer 19

Se me ocurrió tal solución:

// Utils.ts
export function convertEnumValuesToString(obj) {
    Object.keys(obj).forEach(function (key) {
        if (isNaN(+key)) {
            Object.defineProperty(obj, key, {
                value: key,
                enumerable: true
            });
        }
    });
    return obj;
}

// actions/hello.ts
import { convertEnumValuesToString } from ''../utils''

export enum actionTypes {
    GREETING,
    FAREWELL_INIT,
    FAREWELL_DONE
}

console.log(actionTypes .GREETING) // 0
convertEnumValuesToString(actionTypes); // override to same key-based string values
console.log(actionTypes .GREETING) // "GREETING"

Answer 20

Si lo que quieres es principalmente una depuración fácil (con bastante comprobación de tipo) y no necesitas especificar valores especiales para la enumeración, esto es lo que estoy haciendo:

export type Enum = { [index: number]: string } & { [key: string]: number } | Object;

/**
 * inplace update
 * */
export function enum_only_string<E extends Enum>(e: E) {
  Object.keys(e)
    .filter(i => Number.isFinite(+i))
    .forEach(i => {
      const s = e[i];
      e[s] = s;
      delete e[i];
    });
}

enum AuthType {
  phone, email, sms, password
}
enum_only_string(AuthType);

Si desea admitir el almacenamiento de datos / códigos heredados, puede mantener las teclas numéricas.

De esta manera, puede evitar escribir los valores dos veces.

Answer 21

TypeScript 0.9.0.1

enum e{
    hello = 1,
    somestr = ''world''
};

alert(e[1] + '' '' + e.somestr);

TypeScript Playground

Answer 22

TypeScript 2.1

Esto también se puede hacer de esta manera. Espero que ayude a alguien.

const AwesomeType = {
    Foo: "foo" as "foo",
    Bar: "bar" as "bar"
};

type AwesomeType = (typeof AwesomeType)[keyof typeof AwesomeType];

console.log(AwesomeType.Bar); // returns bar
console.log(AwesomeType.Foo); // returns foo

function doSth(awesometype: AwesomeType) {
    console.log(awesometype);
}

doSth("foo") // return foo
doSth("bar") // returns bar
doSth(AwesomeType.Bar) // returns bar
doSth(AwesomeType.Foo) // returns foo
doSth(''error'') // does not compile

Answer 23

Una manera de piratear esto es:

CallStatus.ts

enum Status
{
    PENDING_SCHEDULING,
    SCHEDULED,
    CANCELLED,
    COMPLETED,
    IN_PROGRESS,
    FAILED,
    POSTPONED
}

export = Status

Utils.ts

static getEnumString(enum:any, key:any):string
{
    return enum[enum[key]];
}

Cómo utilizar

Utils.getEnumString(Status, Status.COMPLETED); // = "COMPLETED"

Answer 24

TypeScript <2.4

/** Utility function to create a K:V from a list of strings */
function strEnum<T extends string>(o: Array<T>): {[K in T]: K} {
  return o.reduce((res, key) => {
    res[key] = key;
    return res;
  }, Object.create(null));
}

/**
  * Sample create a string enum
  */

/** Create a K:V */
const Direction = strEnum([
  ''North'',
  ''South'',
  ''East'',
  ''West''
])
/** Create a Type */
type Direction = keyof typeof Direction;

/** 
  * Sample using a string enum
  */
let sample: Direction;

sample = Direction.North; // Okay
sample = ''North''; // Okay
sample = ''AnythingElse''; // ERROR!

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

En el enlace de origen, puede encontrar formas más sencillas de lograr el tipo literal de cadena.

Answer 25

TypeScript 2.4+

Ahora puede asignar valores de cadena directamente a los miembros de la enumeración:

enum Season {
    Winter = "winter",
    Spring = "spring",
    Summer = "summer",
    Fall = "fall"
}

Vea #15486 para más información.

TypeScript 1.8+

En TypeScript 1.8+, puede crear un tipo de cadena literal para definir el tipo y un objeto con el mismo nombre para la lista de valores. Imita el comportamiento esperado de una cadena de caracteres.

Aquí hay un ejemplo:

type MyStringEnum = "member1" | "member2";

const MyStringEnum = {
    Member1: "member1" as MyStringEnum,
    Member2: "member2" as MyStringEnum
};

Que funcionará como una enumeración de cadena:

// implicit typing example
let myVariable = MyStringEnum.Member1; // ok
myVariable = "member2";                // ok
myVariable = "some other value";       // error, desired

// explict typing example
let myExplicitlyTypedVariable: MyStringEnum;
myExplicitlyTypedVariable = MyStringEnum.Member1; // ok
myExplicitlyTypedVariable = "member2";            // ok
myExplicitlyTypedVariable = "some other value";   // error, desired

Asegúrate de escribir todas las cadenas en el objeto! Si no lo hace, en el primer ejemplo anterior, la variable no se escribiría implícitamente en MyStringEnum .

Answer 26

//to access the enum with its string value you can convert it to object 
//then you can convert enum to object with proberty 
//for Example :

enum days { "one" =3, "tow", "Three" }

let _days: any = days;

if (_days.one == days.one)
{ 
    alert(_days.one + '' | '' + _days[4]);
}

Answer 27

export enum PaymentType {
                Cash = 1,
                Credit = 2
            }
var paymentType = PaymentType[PaymentType.Cash];