Crea un enum con valori stringa

Il seguente codice può essere utilizzato per creare un enumin TypeScript:

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

E i valori sono accessibili da:

e.hello;
e.world;

Come posso creare un enumcon valori stringa?

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

TypeScript 2.4

Ora ha enumerazioni di stringa, quindi il tuo codice funziona:

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

🌹

TypeScript 1.8

Da TypeScript 1.8 è possibile utilizzare i tipi letterali di stringa per fornire un'esperienza affidabile e sicura per i valori di stringa con nome (che è parzialmente utilizzato per gli enum).

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

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

Supporto legacy

Gli enumeratori in TypeScript sono basati su numeri.

Puoi usare una classe con membri statici però:

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

Potresti anche diventare semplice:

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

Aggiornamento: in base al requisito per poter fare qualcosa come var test:E = E.hello;il seguente soddisfa questo:

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

Nell'ultima versione (1.0RC) di TypeScript, puoi usare enum come questo:

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

Aggiornamento 1

Per ottenere il valore numerico del membro enum dal valore stringa, è possibile utilizzare questo:

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

Aggiornamento 2

Nell'ultimo TypeScript 2.4 sono stati introdotti enumeratori di stringhe, come questo:

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

    // Aliases
    RemoveUser = DeleteUser,
}

Per maggiori informazioni su TypeScript 2.4, leggi il blog su MSDN .

TypeScript 2.4+

Ora puoi assegnare i valori di stringa direttamente ai membri enum:

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

Vedi # 15486 per maggiori informazioni.

TypeScript 1.8+

In TypeScript 1.8+, è possibile creare un tipo letterale di stringa per definire il tipo e un oggetto con lo stesso nome per l'elenco di valori. Imita il comportamento previsto di un enum string.

Ecco un esempio:

type MyStringEnum = "member1" | "member2";

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

Che funzionerà come un enum string:

// 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

Assicurati di digitare tutte le stringhe nell'oggetto! In caso contrario, nel primo esempio sopra la variabile non verrebbe digitata in modo implicito MyStringEnum.

In TypeScript 0.9.0.1, sebbene si verifichi un errore del compilatore, il compilatore può comunque compilare il file ts nel file js. Il codice funziona come previsto e Visual Studio 2012 può supportare il completamento automatico del codice.

Aggiornare :

In sintassi, TypeScript non ci consente di creare un enum con valori stringa, ma possiamo hackerare il compilatore: 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']);

Terreno di gioco

TypeScript 2.1 +

I tipi di ricerca , introdotti in TypeScript 2.1 consentono un altro modello per la simulazione di enumerazioni di stringhe:

// 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 versione 2.4, TypeScript ha introdotto il supporto nativo per gli enumerazioni di stringhe, quindi la soluzione sopra non è necessaria. Dai documenti TS:

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

Perché non usare semplicemente il modo nativo di accedere alle stringhe di un enum.

enum e {
  WHY,
  NOT,
  USE,
  NATIVE
}

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

Puoi usare enumerazioni di stringa nell'ultimo TypeScript:

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

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

AGGIORNAMENTO - 2016

Un modo leggermente più robusto di creare una serie di stringhe che uso per React in questi giorni è il seguente:

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

Ecco una soluzione abbastanza pulita che consente l'ereditarietà, usando TypeScript 2.0. Non l'ho provato su una versione precedente.

Bonus: il valore può essere di qualsiasi 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: // ...
}

Un modo bizzarro per questo è: -

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]];
}

Come usare

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

Questo funziona per me:

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)

Aggiornamento: poco dopo aver pubblicato questo ho scoperto un altro modo, ma ho dimenticato di pubblicare un aggiornamento (tuttavia, qualcuno l'ha già menzionato sopra):

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

Dichiaro solo un'interfaccia e utilizzo una variabile di quel tipo per accedere all'enum. Mantenere l'interfaccia e l'enum sincronizzati è in realtà facile, poiché TypeScript si lamenta se qualcosa cambia nell'enum, in questo modo.

errore TS2345: l'argomento di tipo 'typeof EAbFlagEnum' non è assegnabile al parametro di tipo 'IAbFlagEnum'. La proprietà 'Sposta' non è presente nel tipo 'typeof EAbFlagEnum'.

Il vantaggio di questo metodo è che non è richiesto il cast di tipo per usare l'enum (interfaccia) in varie situazioni, e quindi sono supportati più tipi di situazioni, come switch / case.

// 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;

L'uso della variabile, anziché dell'enum, produce i risultati desiderati.

var strVal: string = AbFlagEnum.Edit;

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

Le bandiere erano un'altra necessità per me, quindi ho creato un modulo NPM che si aggiunge a questo esempio e include test.

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

AGGIORNAMENTO: TypeScript 3.4

Puoi semplicemente usare as const:

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

TypeScript 2.1

Questo può essere fatto anche in questo modo. Spero che aiuti qualcuno.

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

Con i trasformatori personalizzati ( https://github.com/Microsoft/TypeScript/pull/13940 ), disponibile in typescript @ next, è possibile creare un oggetto enum like con valori stringa da tipi letterali stringa.

Per favore, guarda nel mio pacchetto npm, ts-transformer-enumerate .

Esempio di utilizzo:

// 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'

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!

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

Al link sorgente puoi trovare modi più e più semplici per realizzare il tipo letterale di stringa

Ci sono molte risposte, ma non vedo soluzioni complete. Il problema con la risposta accettata, inoltre enum { this, one }, è che disperde il valore di stringa che si sta utilizzando in molti file. Non mi piace neanche l '"aggiornamento", è complesso e non sfrutta anche i tipi. Penso che la risposta di Michael Bromley sia la più corretta, ma la sua interfaccia è un po 'una seccatura e potrebbe fare con un tipo.

Sto usando TypeScript 2.0. * Ecco cosa farei

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

let greet: Greeting = Greeting.hello

Ha anche informazioni di tipo / passaggio del mouse molto più belle quando si utilizza un IDE utile. Lo svantaggio è che devi scrivere le stringhe due volte, ma almeno è solo in due punti.

La risposta di @ basarat è stata fantastica. Ecco un esempio semplificato ma un po 'esteso che puoi usare:

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...
}

Di recente ho riscontrato questo problema con TypeScript 1.0.1 e risolto in questo modo:

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)

Penso che dovresti provare con questo, in questo caso il valore della variabile non cambierà e funziona in modo simile agli enum, usando come una classe funziona anche l'unico svantaggio è che puoi cambiare il valore della variabile statica per errore ed è quello che non vogliamo in enum.

namespace portal {

export namespace storageNames {

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

  }
}

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

//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]);
}

Piccolo js-hacky ma funziona: e[String(e.hello)]

Se quello che vuoi è principalmente un debug semplice (con un discreto controllo del tipo) e non è necessario specificare valori speciali per l'enum, questo è quello che sto facendo:

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

Se si desidera supportare l'archiviazione di codice / dati legacy, è possibile conservare i tasti numerici.

In questo modo, puoi evitare di digitare i valori due volte.

Enum molto, molto, molto semplice con stringa (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))
}

Ho provato in TypeScript 1.5 come sotto e ha funzionato per me

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

stavo cercando un modo per implementare le descrizioni negli enumerati dattiloscritti (v2.5) e questo schema ha funzionato per me:

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

TypeScript 0.9.0.1

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

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

Parco giochi TypeScript