¿Cómo se obtienen los nombres de las entradas enum de TypeScript?

Me gustaría saber cómo iterar una enumeración de TypeScript y cada nombre de símbolo enumerado.

P.ej,

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

El código que publicaste funcionará; imprimirá todos los miembros de la enumeración, incluidos los valores de los miembros enum. Por ejemplo, el siguiente código:

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

Se imprimirá lo siguiente:

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

Si, en cambio, solo desea los nombres de los miembros y no los valores, podría hacer algo como esto:

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

Eso imprimirá solo los nombres:

Miembro de Enum: bar

Miembro de Enum: foo

Advertencia: esto se basa ligeramente en un detalle de implementación: TypeScript comstack enumeraciones a un objeto JS con los valores enum como miembros del objeto. Si TS decidió implementarlos de manera diferente en el futuro, la técnica anterior podría romperse.

Aunque la respuesta ya está provista, casi nadie señaló los documentos

Aquí hay un fragmento

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

Asumiendo que te apegas a las reglas y solo produces enumeraciones con valores numéricos, puedes usar este código. Esto maneja correctamente el caso donde tienes un nombre que casualmente es un número válido

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

Para mí, una forma más fácil, práctica y directa de entender lo que está sucediendo es la siguiente enumeración:

 enum colors { red, green, blue }; 

Se convertirá esencialmente a esto:

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

Debido a esto, lo siguiente será cierto:

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

Esto crea una manera fácil de obtener el nombre de un enumerado de la siguiente manera:

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

También crea una forma agradable de convertir una cadena a un valor enumerado.

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

Las dos situaciones anteriores son una situación mucho más común, porque generalmente está mucho más interesado en el nombre de un valor específico y en la serialización de valores de una manera genérica.

Si solo busca los nombres e itera después, use:

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

Con TypeScript Version 1.8.9 actual utilizo Enums escritos:

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

con resultados en este objeto Javascript:

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

así que tengo que consultar a través de claves y valores y solo devolver valores:

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

Y recibo las teclas de opción en una matriz:

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

Puede usar el paquete de enum-values que escribí cuando tuve el mismo problema:

Git: enum-values

 var names = EnumValues.getNames(myEnum); 

Esta solución también funciona.

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

Deje que ts-enum-util ( github , npm ) haga el trabajo por usted y proporcione una gran cantidad de utilidades adicionales de tipo seguro. Funciona con cadenas y enumeraciones numéricas, ignorando correctamente las entradas de búsqueda inversa del índice numérico para las enumeraciones numéricas:

Enum de cadena:

 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 numérico:

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

Comenzando desde el texto typescript 2.4, la enumeración ya no contendría la clave como miembro. fuente del readme de Typescript

La advertencia es que las enumeraciones inicializadas por cadenas no se pueden mapear de forma inversa para obtener el nombre del miembro enum original. En otras palabras, no puede escribir Colores [“ROJO”] para obtener la cadena “Rojo”.

Mi solución:

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

En base a algunas respuestas anteriores, se me ocurrió esta firma de función de tipo seguro:

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

el tipo de stringVals es 'entry1' | 'entry2' 'entry1' | 'entry2'

Véalo en acción

Encuentro esa solución más elegante:

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

Muestra:

 bar foo 

A partir de Typescript 2.4, las enumeraciones pueden contener intializadores de cadenas https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-4.html

Esto te permite escribir:

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

y obtener esta salida:

Uno es primero

La única solución que funciona para mí en todos los casos (incluso si los valores son cadenas) es la siguiente:

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

De acuerdo con la documentación mecanografiada, podemos hacer esto a través de Enum con funciones estáticas.

Obtenga Enum Name con funciones estáticas

 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 

Para leer más acerca de Enum con la función estática, siga el siguiente enlace https://basarat.gitbooks.io/typescript/docs/enums.html