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