Come si ottengono i nomi delle voci enum di TypeScript?

Mi piacerebbe sapere come iterare un’enumerazione TypeScript e ogni nome di simbolo enumerato.

Per esempio,

enum myEnum { entry1, entry2 } for (var entry in myEnum) { // use entry's name here, eg, "entry1" } 

Il codice che hai postato funzionerà; stamperà tutti i membri dell’enumerazione, compresi i valori dei membri dell’enum. Ad esempio, il seguente codice:

 enum myEnum { bar, foo } for (var enumMember in myEnum) { console.log("enum member: ", enumMember); } 

Stamperà il seguente:

 Enum member: 0 Enum member: 1 Enum member: bar Enum member: foo 

Se preferisci invece solo i nomi dei membri, e non i valori, potresti fare qualcosa del genere:

 for (var enumMember in myEnum) { var isValueProperty = parseInt(enumMember, 10) >= 0 if (isValueProperty) { console.log("enum member: ", myEnum[enumMember]); } } 

Questo stamperà solo i nomi:

Membro Enum: bar

Membro Enum: foo

Avvertenza: questo si basa un po ‘su un dettaglio di implementazione: TypeScript compila enum su un object JS con i valori enum che sono membri dell’object. Se i TS decidessero di implementarli in modo diverso in futuro, la suddetta tecnica potrebbe rompersi.

Sebbene la risposta sia già fornita, quasi nessuno ha indicato i documenti

Ecco un frammento

 enum Enum { A } let nameOfA = Enum[Enum.A]; // "A" 

Supponendo che rispetti le regole e produci solo enumerazioni con valori numerici, puoi usare questo codice. Questo gestisce correttamente il caso in cui si ha un nome che è per coincidenza un numero valido

 enum Color { Red, Green, Blue, "10" // wat } var names: string[] = []; for(var n in Color) { if(typeof Color[n] === 'number') names.push(n); } console.log(names); // ['Red', 'Green', 'Blue', '10'] 

Per me un modo più semplice, pratico e diretto per capire cosa sta succedendo, è la seguente enumerazione:

 enum colors { red, green, blue }; 

Verranno convertiti essenzialmente in questo:

 var colors = { red: 0, green: 1, blue: 2, [0]: "red", [1]: "green", [2]: "blue" } 

Per questo motivo, sarà vero quanto segue:

 colors.red === 0 colors[colors.red] === "red" colors["red"] === 0 

Questo crea un modo semplice per ottenere il nome di un enumerato come segue:

 var color: colors = colors.red; console.log("The color selected is " + colors[color]); 

Crea anche un buon modo per convertire una stringa in un valore enumerato.

 var colorName: string = "green"; var color: colors = colors.red; if (colorName in colors) color = colors[colorName]; 

Le due situazioni sopra descritte sono di gran lunga più comuni, perché di solito sei molto più interessato al nome di un valore specifico e alla serializzazione dei valori in modo generico.

Se si cercano solo i nomi e iterate in seguito, utilizzare:

 Object.keys(myEnum).map(key => myEnum[key]).filter(value => typeof value === 'string') as string[]; 

Con l’attuale versione di TypeScript 1.8.9 uso Enum tipizzati:

 export enum Option { OPTION1 = 'this is option 1', OPTION2 = 'this is option 2' } 

con risultati in questo object Javascript:

 Option = { "OPTION1": "this is option 1", "OPTION2": "this is option 2", "this is option 1": "OPTION1", "this is option 2": "OPTION2" } 

quindi devo interrogare attraverso chiavi e valori e restituire solo i valori:

 let optionNames: Array = []; for (let enumValue in Option) { let optionNameLength = optionNames.length; if (optionNameLength === 0) { this.optionNames.push([enumValue, Option[enumValue]]); } else { if (this.optionNames[optionNameLength - 1][1] !== enumValue) { this.optionNames.push([enumValue, Option[enumValue]]); } } } 

E ricevo le chiavi di opzione in una matrice:

 optionNames = [ "OPTION1", "OPTION2" ]; 

Puoi usare il pacchetto enum-values che ho scritto quando ho avuto lo stesso problema:

Git: enum-values

 var names = EnumValues.getNames(myEnum); 

Anche questa soluzione funziona.

 enum ScreenType { Edit = 1, New = 2, View = 4 } var type: ScreenType = ScreenType.Edit; console.log(ScreenType[type]); //Edit 

Lascia che ts-enum-util ( github , npm ) faccia il lavoro per te e fornisca molte altre utility di sicurezza del tipo. Funziona con enumerazioni stringa e numeriche, ignorando correttamente le voci di ricerca inversa dell’indice numerico per le enumerazioni numeriche:

Enum di corda:

 import {$enum} from "ts-enum-util"; enum Option { OPTION1 = 'this is option 1', OPTION2 = 'this is option 2' } // type: ("OPTION1" | "OPTION2")[] // value: ["OPTION1", "OPTION2"] const keys= $enum(Option).getKeys(); // type: Option[] // value: ["this is option 1", "this is option 2"] const values = $enum(Option).getValues(); 

Enumerico:

 enum Option { OPTION1, OPTION2 } // type: ("OPTION1" | "OPTION2")[] // value: ["OPTION1", "OPTION2"] const keys= $enum(Option).getKeys(); // type: Option[] // value: [0, 1] const values = $enum(Option).getValues(); 

A partire dal typescript 2.4, l’enumerazione non conterrebbe più la chiave come membro. fonte dal readme di Typescript

L’avvertenza è che enum inizializzati da stringhe non possono essere mappati in reverse per ottenere il nome del membro enum originale. In altre parole, non è ansible scrivere Colors [“RED”] per ottenere la stringa “Red”.

La mia soluzione:

 export const getColourKey = (value: string ) => { let colourKey = ''; for (const key in ColourEnum) { if (value === ColourEnum[key]) { colourKey = key; break; } } return colourKey; }; 

Sulla base di alcune risposte sopra ho trovato questa firma della funzione sicura del tipo:

 export function getStringValuesFromEnum(myEnum: T): keyof T { return Object.keys(myEnum).filter(k => typeof (myEnum as any)[k] === 'number') as any; } 

Uso:

 enum myEnum { entry1, entry2 }; const stringVals = getStringValuesFromEnum(myEnum); 

il tipo di stringVals è 'entry1' | 'entry2' 'entry1' | 'entry2'

Guardalo in azione

Trovo quella soluzione più elegante:

 for (let val in myEnum ) { if ( isNaN( parseInt( val )) ) console.log( val ); } 

Visualizza:

 bar foo 

A partire da Typescript 2.4, le enumerazioni possono contenere string intializers https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-4.html

Questo ti permette di scrivere:

  enum Order { ONE = "First", TWO = "Second" } console.log(`One is ${Order.ONE.toString()}`); 

e ottieni questo risultato:

Uno è il primo

L’unica soluzione che funziona per me in tutti i casi (anche se i valori sono stringhe) è la seguente:

 var enumToString = function(enumType, enumValue) { for (var enumMember in enumType) { if (enumType[enumMember]==enumValue) return enumMember } } 

Secondo la documentazione typescript, possiamo farlo tramite Enum con funzioni statiche.

Ottieni il nome Enum con funzioni statiche

 enum myEnum { entry1, entry2 } namespace myEnum { export function GetmyEnumName(m: myEnum) { return myEnum[m]; } } now we can call it like below myEnum.GetmyEnumName(myEnum.entry1); // result entry1 

per leggere di più su Enum con la funzione statica, segui il link sottostante https://basarat.gitbooks.io/typescript/docs/enums.html