Crea un enum con valori stringa in TypeScript

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

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

e i valori sono accessibili da:

 e.hello; e.world; 

Come posso creare un enum con valori stringa?

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

TypeScript 2.4

Ora ha enumerazioni di stringhe quindi il tuo codice funziona solo:

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

🌹

TypeScript 1.8

Dal momento che TypeScript 1.8 è ansible utilizzare i tipi di stringa letterale per fornire un’esperienza affidabile e sicura per i valori di stringa con nome (che è in parte l’utilizzo di enumerazioni).

 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

Le enumerazioni in TypeScript sono basate su numeri.

Puoi usare una class con membri statici però:

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

Potresti anche andare chiaro:

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

Aggiornamento: basato sul requisito di poter fare qualcosa come il 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 enumerazioni come questa:

 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, puoi utilizzare questo:

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

Aggiornamento 2

Nell’ultimo TypeScript 2.4, sono state introdotte enumerazioni di stringhe, come questa:

 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 ansible assegnare i valori stringa direttamente ai membri enum:

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

Vedi # 15486 per ulteriori informazioni.

TypeScript 1.8+

In TypeScript 1.8+, è ansible creare un tipo di stringa letterale per definire il tipo e un object con lo stesso nome per l’elenco di valori. Imita il comportamento atteso di uno string enum.

Ecco un esempio:

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

Che funzionerà come un enum di stringa:

 // 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’object! In caso contrario, nel primo esempio sopra la variabile non verrà digitata implicitamente su MyStringEnum .

In TypeScript 0.9.0.1, anche se si verifica un errore del compilatore, il compilatore può ancora 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 syntax, TypeScript non ci consente di creare un enum con valori stringa, ma possiamo hackerare il compilatore: p

 enum Link { LEARN = '/Tutorial', PLAY = '/Playground', GET_IT = '/#Download', RUN_IT = '/Samples', JOIN_IN = '/#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 pattern per simulare 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 enumerazioni di stringhe, quindi la soluzione di cui sopra non è necessaria. Dai documenti TS:

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

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

 enum e { WHY, NOT, USE, NATIVE } e[e.WHY] // this returns string 'WHY' 

È ansible utilizzare le enumerazioni delle stringhe nell’ultimo TypeScript:

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

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


AGGIORNAMENTO – 2016

Un modo leggermente più robusto per creare un set di stringhe che uso per React in questi giorni è come questo:

 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à, utilizzando TypeScript 2.0. Non ho provato questo su una versione precedente.

Bonus: il valore può essere qualsiasi tipo!

 export class Enum { public constructor(public readonly value: T) {} public toString() { return this.value.toString(); } } export class PrimaryColor extends Enum { 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 hacky 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 postato questo ho scoperto un altro modo, ma ho dimenticato di pubblicare un aggiornamento (tuttavia, qualcuno lo ha già menzionato sopra):

 enum MyEnum { value1 = "value1 ", value2 = "value2 ", value3 = "value3 " } 

TypeScript 2.1

Questo può anche essere fatto 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 

Dichiaro solo un’interfaccia e uso una variabile di quel tipo per accedere all’enum. Mantenere l’interfaccia e enum in sincronia è davvero facile, dal momento che TypeScript si lamenta se qualcosa cambia nell’enumerazione, in questo modo.

errore TS2345: l’argomento di tipo ‘typeof EAbFlagEnum’ non è assegnabile al parametro di tipo ‘IAbFlagEnum’. La proprietà ‘Move’ manca nel tipo ‘typeof EAbFlagEnum’.

Il vantaggio di questo metodo non è il casting di tipo è necessario per utilizzare l’enum (interfaccia) in varie situazioni, e quindi sono supportati più tipi di situazioni, come ad esempio switch / case.

 // Declare a TypeScript enum using unique string // (per hack mentioned by zjc0816) enum EAbFlagEnum { None =  "none", Select =  "sel", Move =  "mov", Edit =  "edit", Sort =  "sort", Clone =  "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, piuttosto che l’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 aggiunge a questo esempio e include test.

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

Con i trasformatori personalizzati ( https://github.com/Microsoft/TypeScript/pull/13940 ), disponibile in typescript @ next, puoi creare enum come object con valori stringa dai tipi letterali stringa.

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

Esempio di utilizzo:

 // The signature of `enumerate` here is `function enumerate(): { [K in T]: K };` import { enumerate } from 'ts-transformsr-enumerate'; type Colors = 'green' | 'yellow' | 'red'; const Colors = enumerate(); 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(o: Array): {[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ù semplici per realizzare un tipo di stringa letterale

Ci sono molte risposte, ma non vedo nessuna soluzione completa. Il problema con la risposta accettata, così come enum { this, one } , è che disperde il valore di stringa che si sta usando in molti file. Non mi piace nemmeno l ‘”aggiornamento”, è complesso e non fa leva anche sui tipi. Penso che la risposta di Michael Bromley sia la più corretta, ma la sua interfaccia è un po ‘complicata e potrebbe fare con un tipo.

Sto usando TypeScript 2.0. * Ecco cosa vorrei fare

 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 hover-over molto più belle quando si usa un IDE utile. Lo svantaggio è che devi scrivere le stringhe due volte, ma almeno è solo in due punti.

@ la risposta di basarat è stata grandiosa. 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 ha affrontato 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 funzionerà abbastanza come l’enumerazione, usando come una class funziona anche l’unico svantaggio è che per errore puoi cambiare il valore della variabile statica e questo è ciò che non vogliamo nelle enumerazioni.

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

Ho trovato una soluzione del genere:

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

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

Se quello che vuoi è principalmente facile debug (con un controllo di tipo abbastanza) 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: 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 il codice legacy / l’archiviazione dei dati, è ansible mantenere 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 in enunciati typescript (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); 

Campo di gioco di TypeScript