514

我想迭代一个 TypeScript 枚举对象并获取每个枚举的符号名称,例如: enum myEnum { entry1, entry2 }

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

40 回答 40

627

尽管已经提供了答案,但几乎没有人指出文档

这是一个片段

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

请记住,字符串枚举成员根本不会生成反向映射。

于 2017-02-11T04:42:11.533 回答
339

您发布的代码将起作用;它将打印出枚举的所有成员,包括枚举成员的值。例如,下面的代码:

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 member: bar  
Enum member: foo

警告:这稍微依赖于实现细节:TypeScript 将枚举编译为 JS 对象,枚举值是对象的成员。如果 TS 决定在未来以不同的方式实现它们,上述技术可能会失效。

于 2013-08-07T19:30:44.877 回答
101

对我来说,了解正在发生的事情的一种更简单、实用和直接的方法是以下枚举:

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

上述两种情况是更为常见的情况,因为通常您对特定值的名称和以通用方式序列化值更感兴趣。

于 2016-09-11T18:52:38.527 回答
77

如果您只搜索名称并稍后进行迭代,请使用:

Object.keys(myEnum).map(key => myEnum[key]).filter(value => typeof value === 'string') as string[];
于 2017-03-29T11:02:29.657 回答
63

假设您遵守规则并且只生成带有数值的枚举,您可以使用此代码。这可以正确处理您的姓名恰好是有效数字的情况

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']
于 2013-08-07T19:46:05.080 回答
32

对于当前的 TypeScript 版本 1.8.9,我使用类型化枚举:

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" ];
于 2016-04-11T10:17:50.373 回答
29

从 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()}`);

并得到这个输出:

一个是第一

于 2018-08-13T15:53:00.593 回答
27

似乎这里的所有答案都不适用于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]
于 2020-03-20T14:22:34.590 回答
26

该解决方案也有效。

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

var type: ScreenType = ScreenType.Edit;

console.log(ScreenType[type]); //Edit
于 2017-10-09T18:25:06.000 回答
18

简而言之

如果您enums的情况如下:

export enum Colors1 {
  Red = 1,
  Green = 2,
  Blue = 3
}

获取特定的文本和值:

console.log(Colors1.Red); // 1 
console.log(Colors1[Colors1.Red]); // Red

获取值和文本列表:

public getTextAndValues(e: { [s: number]: string }) {
  for (const enumMember in e) {
    if (parseInt(enumMember, 10) >= 0) {
      console.log(e[enumMember]) // Value, such as 1,2,3
      console.log(parseInt(enumMember, 10)) // Text, such as Red,Green,Blue
    }
  }
}
this.getTextAndValues(Colors1)

如果您enums的情况如下:

export enum Colors2 {
  Red = "Red",
  Green = "Green",
  Blue = "Blue"
}

获取特定的文本和值:

console.log(Colors2.Red); // Red
console.log(Colors2["Red"]); // Red

获取值和文本列表:

public getTextAndValues(e: { [s: string]: string }) {
  for (const enumMember in e) {
    console.log(e[enumMember]);// Value, such as Red,Green,Blue
    console.log(enumMember); //  Text, such as Red,Green,Blue
  }
}
this.getTextAndValues(Colors2)
于 2020-12-19T08:58:55.693 回答
16

ts-enum-util( github , npm ) 为您完成工作并提供许多额外的类型安全实用程序。适用于字符串和数字枚举,正确忽略数字枚举的数字索引反向查找条目:

字符串枚举:

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();
于 2018-02-24T06:00:41.777 回答
15

这里发现的另一个有趣的解决方案是使用 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
于 2019-03-12T14:06:39.657 回答
10

从 TypeScript 2.4 开始,枚举不再包含作为成员的键。来自 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;
};
于 2018-01-25T07:55:35.277 回答
10

我厌倦了浏览错误的答案,我自己做了。

  • 这个有测试。
  • 适用于所有类型的枚举。
  • 输入正确。
type EnumKeys<Enum> = Exclude<keyof Enum, number>

const enumObject = <Enum extends Record<string, number | string>>(e: Enum) => {
    const copy = {...e} as { [K in EnumKeys<Enum>]: Enum[K] };
    Object.values(e).forEach(value => typeof value === 'number' && delete copy[value]);
    return copy;
};

const enumKeys = <Enum extends Record<string, number | string>>(e: Enum) => {
    return Object.keys(enumObject(e)) as EnumKeys<Enum>[];
};

const enumValues = <Enum extends Record<string, number | string>>(e: Enum) => {
    return [...new Set(Object.values(enumObject(e)))] as Enum[EnumKeys<Enum>][];
};

enum Test1 { A = "C", B = "D"}
enum Test2 { A, B }
enum Test3 { A = 0, B = "C" }
enum Test4 { A = "0", B = "C" }
enum Test5 { undefined = "A" }
enum Test6 { A = "undefined" }
enum Test7 { A, B = "A" }
enum Test8 { A = "A", B = "A" }
enum Test9 { A = "B", B = "A" }

console.log(enumObject(Test1)); // {A: "C", B: "D"}
console.log(enumObject(Test2)); // {A: 0, B: 1}
console.log(enumObject(Test3)); // {A: 0, B: "C"}
console.log(enumObject(Test4)); // {A: "0", B: "C"}
console.log(enumObject(Test5)); // {undefined: "A"}
console.log(enumObject(Test6)); // {A: "undefined"}
console.log(enumObject(Test7)); // {A: 0,B: "A"}
console.log(enumObject(Test8)); // {A: "A", B: "A"}
console.log(enumObject(Test9)); // {A: "B", B: "A"}

console.log(enumKeys(Test1)); // ["A", "B"]
console.log(enumKeys(Test2)); // ["A", "B"]
console.log(enumKeys(Test3)); // ["A", "B"]
console.log(enumKeys(Test4)); // ["A", "B"]
console.log(enumKeys(Test5)); // ["undefined"]
console.log(enumKeys(Test6)); // ["A"]
console.log(enumKeys(Test7)); // ["A", "B"]
console.log(enumKeys(Test8)); // ["A", "B"]
console.log(enumKeys(Test9)); // ["A", "B"]

console.log(enumValues(Test1)); // ["C", "D"]
console.log(enumValues(Test2)); // [0, 1]
console.log(enumValues(Test3)); // [0, "C"]
console.log(enumValues(Test4)); // ["0", "C"]
console.log(enumValues(Test5)); // ["A"] 
console.log(enumValues(Test6)); // ["undefined"] 
console.log(enumValues(Test7)); // [0, "A"]
console.log(enumValues(Test8)); // ["A"]
console.log(enumValues(Test9)); // ["B", "A"]

网络版。

于 2021-03-08T17:01:16.240 回答
9

enum-values当我遇到同样的问题时,你可以使用我写的包:

Git:枚举值

var names = EnumValues.getNames(myEnum);
于 2016-07-23T10:20:51.500 回答
8

假设你有一个enum

export enum SCROLL_LABEL_OFFSET {
  SMALL = 48,
  REGULAR = 60,
  LARGE = 112
}

并且您想创建一个基于枚举的类型,而不仅仅是复制和粘贴。您可以使用 anenum来创建您的type这样的:

export type ScrollLabelOffset = keyof typeof SCROLL_LABEL_OFFSET;

结果,您将收到一个type可能值为'SMALL' | 'REGULAR' | 'LARGE'

于 2021-09-14T14:16:13.893 回答
7

基于上面的一些答案,我想出了这个类型安全的函数签名:

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'

看到它在行动

于 2018-04-18T08:13:28.527 回答
6

根据 TypeScript 文档,我们可以通过 Enum 使用静态函数来做到这一点。

使用静态函数获取枚举名称

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 

要阅读有关具有静态功能的枚举的更多信息,请点击以下链接 https://basarat.gitbooks.io/typescript/docs/enums.html

于 2018-09-04T13:39:43.523 回答
6

我写了一个 EnumUtil 类,它通过枚举值进行类型检查:

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

于 2019-02-04T12:47:40.850 回答
6

他们在官方文档中提供了一个称为“反向映射”的概念。它帮助了我:

https://www.typescriptlang.org/docs/handbook/enums.html#reverse-mappings

解决方案非常简单:

enum Enum {
 A,
}

let a = Enum.A;
let nameOfA = Enum[a]; // "A"
于 2021-09-09T16:37:27.457 回答
5

在所有情况下(即使值是字符串)都适用于我的唯一解决方案如下:

var enumToString = function(enumType, enumValue) {
    for (var enumMember in enumType) {
        if (enumType[enumMember]==enumValue) return enumMember
    }
}
于 2018-01-18T15:44:28.333 回答
5

我通过搜索“TypeScript iterate over enum keys”找到了这个问题。所以我只想发布适合我的解决方案。也许它也会对某人有所帮助。

我的情况如下:我想遍历每个枚举键,然后过滤一些键,然后访问一些具有键作为枚举计算值的对象。所以这就是我在没有任何 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]
    }))
于 2019-04-17T16:21:41.300 回答
4

老问题,但是,为什么不使用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]
于 2019-10-28T18:52:00.193 回答
4

如果你有枚举

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
});
于 2020-02-05T23:17:54.163 回答
4

您可以通过这种方式从 Enum 中获取名称数组:

const enumNames: string[] = Object.keys(YourEnum).filter(key => isNaN(Number(key)));
于 2021-04-25T09:41:30.887 回答
4

在 TypeScript 中,枚举被编译为 javascript 中的映射(从键中获取值):

enum MyEnum {
  entry0,
  entry1,
}

console.log(MyEnum['entry0']); // 0
console.log(MyEnum['entry1']); // 1

它还创建了一个反向映射(从值中获取键):

console.log(MyEnum[0]); // 'entry0'
console.log(MyEnum[0]); // 'entry1'

因此,您可以通过执行以下操作访问条目的名称:

console.log(MyEnum[MyEnum.entry0]); // 'entry0'
console.log(MyEnum[MyEnum.entry1]); // 'entry1'

但是,字符串枚举在设计上没有反向映射(请参阅评论拉取请求),因为这可能导致映射对象中的键和值之间发生冲突。

enum MyEnum {
  entry0 = 'value0',
  entry1 = 'value1',
}

console.log(MyEnum['value0']); // undefined
console.log(MyEnum['value1']); // undefined

如果你想强制你的字符串枚举编译一个反向映射(然后你必须确保所有的键和值都不同),你可以使用这个技巧:

enum MyEnum {
  entry0 = <any>'value0',
  entry1 = <any>'value1',
}

console.log(MyEnum['value0']); // 'entry0'
console.log(MyEnum['value1']); // 'entry1'
console.log(MyEnum[MyEnum.entry0]); // 'entry0'
console.log(MyEnum[MyEnum.entry1]); // 'entry1'
于 2022-01-06T17:56:09.963 回答
3

我发现该解决方案更优雅:

for (let val in myEnum ) {

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

它显示:

bar 
foo
于 2016-09-07T14:53:32.597 回答
3

要获取您必须使用的枚举值列表:

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

Object.values(AnimalEnum);
于 2020-06-04T19:21:51.827 回答
3

可以很简短:

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

Object.keys(AnimalEnum).filter(v => typeof v == 'string' && isNaN(v))
于 2021-09-18T07:56:53.953 回答
2

我的枚举是这样的:

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

这样做会返回undefined

UserSorting[UserSorting.SortByUpdatedAt]

为了解决这个问题,我选择了另一种使用管道的方法:

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]);
于 2018-12-15T18:21:20.403 回答
2

我希望这个问题仍然相关。我使用这样的功能:

function enumKeys(target: Record<string, number|string>): string[] {
  const allKeys: string[] = Object.keys(target);
  const parsedKeys: string[] = [];

  for (const key of allKeys) {
    const needToIgnore: boolean
      = target[target[key]]?.toString() === key && !isNaN(parseInt(key));

    if (!needToIgnore) {
      parsedKeys.push(key);
    }
  }

  return parsedKeys;
}

function enumValues(target: Record<string, number|string>): Array<string|number> {
  const keys: string[] = enumKeys(target);
  const values: Array<string|number> = [];

  for (const key of keys) {
    values.push(target[key]);
  }

  return values;
}

例子:

enum HttpStatus {
  OK,
  INTERNAL_ERROR,
  FORBIDDEN = 'FORBIDDEN',
  NOT_FOUND = 404,
  BAD_GATEWAY = 'bad-gateway'
}


console.log(enumKeys(HttpStatus));
// > ["OK", "INTERNAL_ERROR", "FORBIDDEN", "NOT_FOUND", "BAD_GATEWAY"] 

console.log(enumValues(HttpStatus));
// > [0, 1, "FORBIDDEN", 404, "bad-gateway"]
于 2020-12-22T11:51:06.697 回答
2

这对于基于键值的枚举更有效:

enum yourEnum {
  ["First Key"] = "firstWordValue",
  ["Second Key"] = "secondWordValue"
}

Object.keys(yourEnum)[Object.values(yourEnum).findIndex(x => x === yourValue)]
// Result for passing values as yourValue
// FirstKey
// SecondKey
于 2021-04-15T19:25:57.583 回答
1

我写了一个辅助函数来枚举一个枚举:

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
}

该函数返回可以轻松枚举的内容,并且还强制转换为枚举类型。

于 2019-11-21T03:06:28.947 回答
1

这里已经有很多答案了,但我想我还是会把我的解决方案扔到堆栈上。

打字稿游乐场

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'
于 2020-06-02T14:45:41.740 回答
0

使用当前版本的 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
  }
}
于 2020-02-26T17:48:00.343 回答
0

这里有很多答案,考虑到尽管这是 7 岁的问题,我还是查了一下,我想会有更多的人来这里。这是我的解决方案,它比其他解决方案简单一些,它处理纯数字/纯文本/混合值枚举,都一样。

enum funky {
    yum , tum='tum', gum = 'jump', plum = 4
}

const list1 = Object.keys(funky)
  .filter(k => (Number(k).toString() === Number.NaN.toString()));
console.log(JSON.stringify(list1)); // ["yum","tum","gum","plum"]" 

 // for the numeric enum vals (like yum = 0, plum = 4), typescript adds val = key implicitly (0 = yum, 4 = plum)
 // hence we need to filter out such numeric keys (0 or 4)
 
于 2020-12-01T18:49:49.320 回答
0

如果它是你的enum并且你定义如下,名称和值是相同的,它会直接给你条目的名称。

enum myEnum { 
    entry1="entry1", 
    entry2="entry2"
 }

for (var entry in myEnum) { 
    // use entry's name here, e.g., "entry1"
}
于 2021-03-15T16:33:20.750 回答
0

只是为了用所有可能的解决方案来更新这个问题,现在我们可以使用迭代器协议来使任何对象可迭代

enum carsEnum{
  BMW="BMW",
  MERCEDES="Mercedes",
  TOYOTA="toyota",
}

carsEnum.[Symbol.iterator]=function(){
    let keys = Object.keys(carsEnum)
    let idx =0;
    return {
       next:()=>
         (idx<keys.length)?{value:this[keys[idx++]],done:false}:{value:undefined,done:true}
    } 
  }

for(let value of carsEnum){
  console.log(value) //'BMW' 'Mercedes'  'toyota'
}

于 2021-11-20T11:32:06.570 回答
0

数字枚举

enum MyNumericEnum {
 First = 1,
 Second = 2
}

您需要先将其转换为数组:

const values = Object.values(MyNumericEnum);
// ['First', 'Second', 1, 2]

如您所见,它包含键和值。钥匙先走。

之后,您可以检索其密钥:

values.slice(0, values.length / 2);
// ['First', 'Second']

和价值观:

values.slice(values.length / 2);
// [1, 2]

对于字符串枚举,您可以分别Object.keys(MyStringEnum)用于获取键和Object.values(MyStringEnum)获取值。

尽管提取混合 enum的键和值有些挑战。

于 2022-02-22T23:48:14.133 回答
-1

这不完全是您问题的答案,但它是解决您问题的技巧。

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.");
}
于 2019-01-12T22:49:01.207 回答