Come si ottengono i nomi delle voci enum di TypeScript?

Question

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

esempio

enum myEnum { entry1, entry2 } 

for (var entry in myEnum) { 
    // use entry's name here, e.g., "entry1" 
} 

Answer 1

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 si desidera invece solo i nomi dei membri, e non i valori, si potrebbe fare qualcosa di simile:

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

che stamperà fuori solo i nomi:

Enum membro: bar

membro Enum: foo

Avvertimento: questo si basa su un dettaglio leggermente applicazione: compila tipografico enumerazioni ad un oggetto JS con i valori enum essendo membri dell'oggetto. Se i TS decidessero di implementarli in modo diverso in futuro, la suddetta tecnica potrebbe rompersi.

Answer 2

Supponendo che rispetti le regole e produca solo enumerazioni con valori numerici, puoi utilizzare questo codice. Questo gestisce correttamente il caso in cui si dispone di 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'] 

Answer 3

Con dattiloscritto attuale Versione 1.8.9 Io uso Enums scelto:

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

con risultati in questo oggetto 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 valori di ritorno solo:

let optionNames: Array<any> = [];  
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 un array:

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

Answer 4

Wow. Questo finì per essere molto più facile di quanto pensassi, e per me non ha alcun senso.

enum myEnum { entry1, entry2 } 
console.log(myEnum[myEnum.entry1]); // Will output "entry1" to the console. 

Answer 5

È possibile utilizzare il pacchetto enum-values ho scritto quando ho avuto lo stesso problema:

Git: enum-values

var names = EnumValues.getNames(myEnum); 

Answer 6

trovo che la soluzione più elegante:

for (let val in myEnum) { 

if (isNaN(parseInt(val))) 
    console.log(val); 
} 

Esso mostra :

bar 
foo 

Answer 7

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

enum colors { red, green, blue }; 

saranno convertiti essenzialmente a questo:

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

A causa di questo, sarà vero il seguente:

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

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

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

Si crea anche un bel 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 di cui sopra sono di gran lunga la situazione più comune, perché di solito siete molto più interessato in nome di un valore specifico e serializzazione dei valori in modo generico.

Answer 8

Anche se la risposta è già previsto, interessante notare che quasi nessuno indicò il documentation ha un sacco di altre informazioni fresco
Ecco un frammento

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

Answer 9

Se si cerca solo per i nomi e le iterazioni uso successivo :

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

Answer 10

Questa soluzione funziona anche.

enum ScreenType { 
    Edit = 1, 
    New = 2, 
    View = 4 
} 

var type: ScreenType = ScreenType.Edit; 

console.log(ScreenType[type]); //Edit 

Answer 11

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

Answer 12

A partire dal dattiloscritto 2.4, l'enumerazione non conterrebbe la chiave come un membro più. source from Typescript readme

L'avvertenza è che le enumerazioni di stringa inizializzata non possono essere reverse-mappati per ottenere il nome del membro enum originale. In altre parole, non è possibile 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; 
}; 

Answer 13

Let ts-enum-util (github, npm) fare il lavoro per voi e fornire un sacco di utility aggiuntive type-safe. Funziona sia con stringhe e numerici enumerazioni, opportunamente ignorando l'indice numerico inverso le voci di ricerca per le enumerazioni numerici:

stringa enum:

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

enum numerico:

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