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

qué es numeric enums typescript

Question

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, e.g., "entry1"
}

Answer 1

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

Answer 2

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

Aquí hay un fragmento

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

Answer 3

Comenzando desde el texto mecanografiado 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;
};

Answer 4

Con TypeScript Version 1.8.9 actual utilizo Enums escritos:

export enum Option {
OPTION1 = <any>''this is option 1'',
OPTION2 = <any>''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<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]]);
}
}
}

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

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

Answer 5

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

Answer 6

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 compila 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.

Answer 7

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

export function getStringValuesFromEnum<T>(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

Answer 8

Encuentro esa solución más elegante:

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

Muestra:

bar
foo

Answer 9

Esta solución también funciona.

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

Answer 10

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

Answer 11

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.

Answer 12

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

Git: enum-values

var names = EnumValues.getNames(myEnum);

Answer 13

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

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