Как получить имена записей enum?

Я хотел бы повторить TypeScript a enumтип и получить имя каждого перечисляемого символа, например:

enum myEnum { entry1, entry2 }

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

Код, который вы разместили, будет работать; он распечатает всех членов перечисления, включая значения членов перечисления. Например, следующий код:

enum myEnum { bar, foo }

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

Напечатает следующее:

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

Если вместо этого вам нужны только имена членов, а не значения, вы можете сделать что-то вроде этого:

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

Это распечатает только имена:

Член enum: bar

Член enum: foo

Предостережение: это немного зависит от деталей реализации: TypeScript компилирует перечисления в объект JS со значениями перечисления, являющимися членами объекта. Если TS решит реализовать их в будущем иначе, описанная выше техника может сломаться.

Хотя ответ уже предоставлен, почти никто не указал на документы

Вот фрагмент

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

Имейте в виду, что члены перечисления строк вообще не генерируют обратное отображение.

Предполагая, что вы придерживаетесь правил и производите только перечисления с числовыми значениями, вы можете использовать этот код. Это правильно обрабатывает случай, когда у вас есть имя, которое по совпадению является действительным числом

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

Для меня более простой, практичный и прямой способ понять, что происходит, это следующее перечисление:

enum colors { red, green, blue };

Будет преобразован по существу в это:

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

Из-за этого будет выполнено следующее:

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

Это создает простой способ получить имя перечисляемого следующим образом:

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

Это также создает хороший способ преобразовать строку в перечисляемое значение.

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

Вышеуказанные две ситуации являются гораздо более распространенной ситуацией, потому что обычно вас гораздо больше интересует имя определенного значения и его сериализация в общем виде.

Если вы только ищете имена и повторяете позже, используйте:

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

С текущей версией TypeScript 1.8.9 я использую типизированные Enums:

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

с результатами в этом объекте Javascript:

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

поэтому я должен запросить ключи и значения и только вернуть значения:

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

И я получаю ключи опции в массиве:

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

Начиная с TypeScript 2.4, перечисления могут содержать инициализаторы строк https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-4.html.

Это позволяет вам написать:

 enum Order {
      ONE = "First",
      TWO = "Second"
 }

console.log(`One is ${Order.ONE.toString()}`);

и получить этот вывод:

Один первый

Это решение тоже работает.

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

var type: ScreenType = ScreenType.Edit;

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

Другое интересное решение, найденное здесь , использует ES6 Map:

export enum Type {
  low,
  mid,
  high
}

export const TypeLabel = new Map<number, string>([
  [Type.low, 'Low Season'],
  [Type.mid, 'Mid Season'],
  [Type.high, 'High Season']
]);

ИСПОЛЬЗОВАНИЕ

console.log(TypeLabel.get(Type.low)); // Low Season

Пусть ts-enum-util( GitHub , нпм ) сделает всю работу за вас и предоставит множество дополнительных утилит, безопасных для типов. Работает как со строковыми, так и числовыми перечислениями, должным образом игнорируя записи обратного просмотра числового индекса для числовых перечислений:

Строковое перечисление:

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 Option {
    OPTION1,
    OPTION2
}

// type: ("OPTION1" | "OPTION2")[]
// value: ["OPTION1", "OPTION2"]
const keys= $enum(Option).getKeys();

// type: Option[]
// value: [0, 1]
const values = $enum(Option).getValues();

Начиная с TypeScript 2.4, перечисление больше не будет содержать ключ в качестве члена. Исходный текст из readme TypeScript

Предостережение заключается в том, что инициализированные строкой перечисления не могут быть преобразованы в обратный путь для получения исходного имени члена перечисления. Другими словами, вы не можете написать Colors ["RED"], чтобы получить строку "Red".

Мое решение:

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

Вы можете использовать enum-valuesпакет, который я написал, когда у меня была такая же проблема:

Git: enum-значения

var names = EnumValues.getNames(myEnum);

Основываясь на некоторых ответах выше, я придумал эту сигнатуру безопасной для типов функции:

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

Использование:

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

тип stringValsявляется'entry1' | 'entry2'

Увидеть это в действии

Кажется, что ни один из ответов здесь не будет работать со строковыми перечислениями в strict-mode.

Рассмотрим перечисление как:

enum AnimalEnum {
  dog = "dog", cat = "cat", mouse = "mouse"
}

Доступ к этому с помощью AnimalEnum["dog"]может привести к ошибке как:

Element implicitly has an 'any' type because expression of type 'any' can't be used to index type 'typeof AnimalEnum'.ts(7053),

Правильное решение для этого случая, запишите его как:

AnimalEnum["dog" as keyof typeof AnimalEnum]

Я думаю, что лучший способ - просто объявить желаемые значения перечисления. Таким образом, доступ к ним чистый и красивый (каждый раз).

enum myEnum { entry1 = 'VALUE1', entry2 = 'VALUE2' }

for (var entry in myEnum) { 
    console.log(entry);
}

будет производить:

VALUE1
VALUE2

Согласно документации TypeScript, мы можем сделать это через Enum со статическими функциями.

Получить Enum Name со статическими функциями

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 

чтобы узнать больше о Enum со статической функцией, перейдите по ссылке ниже https://basarat.gitbooks.io/typescript/docs/enums.html

Единственное решение, которое работает для меня во всех случаях (даже если значения являются строками), заключается в следующем:

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

Старый вопрос, но почему бы не использовать const карту объектов?

Вместо этого:

enum Foo {
    BAR = 60,
    EVERYTHING_IS_TERRIBLE = 80
}

console.log(Object.keys(Foo))
// -> ["60", "80", "BAR", "EVERYTHING_IS_TERRIBLE"]
console.log(Object.values(Foo))
// -> ["BAR", "EVERYTHING_IS_TERRIBLE", 60, 80]

Сделайте это (обратите внимание на as constактерский состав):

const Foo = {
    BAR: 60,
    EVERYTHING_IS_TERRIBLE: 80
} as const

console.log(Object.keys(Foo))
// -> ["BAR", "EVERYTHING_IS_TERRIBLE"]
console.log(Object.values(Foo))
// -> [60, 80]

Я нашел этот вопрос, выполнив поиск "TypeScript итерации по ключам перечисления". Поэтому я просто хочу опубликовать решение, которое работает для меня в моем случае. Может быть, это кому-то тоже поможет.

Мой случай следующий: я хочу перебрать каждый ключ перечисления, затем отфильтровать некоторые ключи, а затем получить доступ к некоторому объекту, ключи которого являются вычисленными значениями из перечисления. Так вот, как я делаю это без каких-либо ошибок TS.

    enum MyEnum = { ONE = 'ONE', TWO = 'TWO' }
    const LABELS = {
       [MyEnum.ONE]: 'Label one',
       [MyEnum.TWO]: 'Label two'
    }


    // to declare type is important - otherwise TS complains on LABELS[type]
    // also, if replace Object.values with Object.keys - 
    // - TS blames wrong types here: "string[] is not assignable to MyEnum[]"
    const allKeys: Array<MyEnum> = Object.values(MyEnum)

    const allowedKeys = allKeys.filter(
      (type) => type !== MyEnum.ONE
    )

    const allowedLabels = allowedKeys.map((type) => ({
      label: LABELS[type]
    }))

Я написал класс EnumUtil, который выполняет проверку типа по значению enum:

export class EnumUtils {
  /**
   * Returns the enum keys
   * @param enumObj enum object
   * @param enumType the enum type
   */
  static getEnumKeys(enumObj: any, enumType: EnumType): any[] {
    return EnumUtils.getEnumValues(enumObj, enumType).map(value => enumObj[value]);
  }

  /**
   * Returns the enum values
   * @param enumObj enum object
   * @param enumType the enum type
   */
  static getEnumValues(enumObj: any, enumType: EnumType): any[] {
    return Object.keys(enumObj).filter(key => typeof enumObj[key] === enumType);
  }
}

export enum EnumType {
  Number = 'number',
  String = 'string'
}

Как это использовать:

enum NumberValueEnum{
  A= 0,
  B= 1
}

enum StringValueEnum{
  A= 'A',
  B= 'B'
}

EnumUtils.getEnumKeys(NumberValueEnum, EnumType.number);
EnumUtils.getEnumValues(NumberValueEnum, EnumType.number);

EnumUtils.getEnumKeys(StringValueEnum, EnumType.string);
EnumUtils.getEnumValues(StringValueEnum, EnumType.string);

Результат для ключей NumberValueEnum: ["A", "B"]

Результат для значений NumberValueEnum: [0, 1]

Результат для StringValueEnumkeys: ["A", "B"]

Результат для StringValueEnumvalues: ["A", "B"]

Я считаю это решение более элегантным:

for (let val in myEnum ) {

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

Он отображает:

bar 
foo

Мой Enum такой:

export enum UserSorting {
    SortByFullName = "Sort by FullName", 
    SortByLastname = "Sort by Lastame", 
    SortByEmail = "Sort by Email", 
    SortByRoleName = "Sort by Role", 
    SortByCreatedAt = "Sort by Creation date", 
    SortByCreatedBy = "Sort by Author", 
    SortByUpdatedAt = "Sort by Edit date", 
    SortByUpdatedBy = "Sort by Editor", 
}

таким образом, это возвращение не определено :

UserSorting[UserSorting.SortByUpdatedAt]

Чтобы решить эту проблему, я выбрал другой способ сделать это с помощью Pipe:

import { Pipe, PipeTransform } from '@angular/core';

@Pipe({
    name: 'enumKey'
})
export class EnumKeyPipe implements PipeTransform {

  transform(value, args: string[] = null): any {
    let enumValue = args[0];
    var keys = Object.keys(value);
    var values = Object.values(value);
    for (var i = 0; i < keys.length; i++) {
      if (values[i] == enumValue) {
        return keys[i];
      }
    }
    return null;
    }
}

И использовать это:

return this.enumKeyPipe.transform(UserSorting, [UserSorting.SortByUpdatedAt]);

Если у вас есть enum

enum Diet {
  KETO = "Ketogenic",
  ATKINS = "Atkins",
  PALEO = "Paleo",
  DGAF = "Whatever"
}

Тогда вы можете получить ключ и значения, такие как:

Object.keys(Diet).forEach((d: Diet) => {
  console.log(d); // KETO
  console.log(Diet[d]) // Ketogenic
});

Я написал вспомогательную функцию для перечисления перечисления:

static getEnumValues<T extends number>(enumType: {}): T[] {
  const values: T[] = [];
  const keys = Object.keys(enumType);
  for (const key of keys.slice(0, keys.length / 2)) {
    values.push(<T>+key);
  }
  return values;
}

Использование:

for (const enumValue of getEnumValues<myEnum>(myEnum)) {
  // do the thing
}

Функция возвращает то, что может быть легко перечислено, а также приводится к типу enum.

Используя текущую версию TypeScript, вы можете использовать такие функции, чтобы сопоставить Enum с выбранной вами записью. Обратите внимание, что вы не можете определять строковые значения с помощью этих функций, так как они ищут ключи со значением, которое является числом.

enum STATES {
  LOGIN,
  LOGOUT,
}

export const enumToRecordWithKeys = <E extends any>(enumeration: E): E => (
  Object.keys(enumeration)
    .filter(key => typeof enumeration[key] === 'number')
    .reduce((record, key) => ({...record, [key]: key }), {}) as E
);

export const enumToRecordWithValues = <E extends any>(enumeration: E): E => (
  Object.keys(enumeration)
    .filter(key => typeof enumeration[key] === 'number')
    .reduce((record, key) => ({...record, [key]: enumeration[key] }), {}) as E
);

const states = enumToRecordWithKeys(STATES)
const statesWithIndex = enumToRecordWithValues(STATES)

console.log(JSON.stringify({
  STATES,
  states,
  statesWithIndex,
}, null ,2));

// Console output:
{
  "STATES": {
    "0": "LOGIN",
    "1": "LOGOUT",
    "LOGIN": 0,
    "LOGOUT": 1
  },
  "states": {
    "LOGIN": "LOGIN",
    "LOGOUT": "LOGOUT"
  },
  "statesWithIndex": {
    "LOGIN": 0,
    "LOGOUT": 1
  }
}

Здесь уже есть много ответов, но я полагаю, что все равно выложу свое решение в стек.

TypeScript Playground

enum AccountType {
  Google = 'goo',
  Facebook = 'boo',
  Twitter = 'wit',
}

type Key = keyof typeof AccountType // "Google" | "Facebook" | "Twitter"

// this creates a POJO of the enum "reversed" using TypeScript's Record utility
const reversed = (Object.keys(AccountType) as Key[]).reduce((acc, key) => {
  acc[AccountType[key]] = key
  return acc
}, {} as Record<AccountType, string>)

Для ясности:

/*
 * reversed == {
 *   "goo": "Google",
 *   "boo": "Facebook",
 *   "wit": "Twitter",
 * }
 * reversed[AccountType.Google] === "Google" 👍
 */

Ссылка на запись TypeScript

Хорошая вспомогательная функция:

const getAccountTypeName = (type: AccountType) => {
  return reversed[type]
};

// getAccountTypeName(AccountType.Twitter) === 'Twitter'

Чтобы получить список значений перечисления, которые вы должны использовать:

enum AnimalEnum {
  DOG = "dog", 
  CAT = "cat", 
  MOUSE = "mouse"
}

Object.values(AnimalEnum);

Это не совсем ответ на ваш вопрос, но это уловка для решения вашей проблемы.

export module Gender {

  export enum Type {
    Female = 1,
    Male = 2
  };

  export const List = Object.freeze([
    Type[Type.Female] ,
    Type[Type.Male]
  ]);

}

Вы можете расширить свою модель списка так, как вы хотите.

export const List = Object.freeze([
    { name: Type[Type.Female], value: Type.Female } ,
    { name: Type[Type.Male], value: Type.Male }
  ]);

Теперь вы можете использовать его следующим образом:

for(const gender of Gender.List){
  console.log(gender.name);
  console.log(gender.value);
}

или:

if(i === Gender.Type.Male){
  console.log("I am a man.");
}