枚举是运行时存在的真实对象。所以你可以这样反向映射:

let value = GoalProgressMeasurements.Not_Measured;
console.log(GoalProgressMeasurements[value]);
// => Not_Measured

基于此，您可以使用以下代码:

export enum GoalProgressMeasurements {
    Percentage = 1,
    Numeric_Target = 2,
    Completed_Tasks = 3,
    Average_Milestone_Progress = 4,
    Not_Measured = 5
}

let map: {id: number; name: string}[] = [];

for(var n in GoalProgressMeasurements) {
    if (typeof GoalProgressMeasurements[n] === 'number') {
        map.push({id: <any>GoalProgressMeasurements[n], name: n});
    }
}

console.log(map);

参考:https://www.typescriptlang.org/docs/handbook/enums.html

我不建议在需要枚举条目列表的情况下使用TS enum。

在运行时，Enum是作为对象实现的，但它只在这种情况下工作:

enum X {
  Z = 'z',
  F = 'f'
};

console.log(Object.values(X))
console.log(Object.keys(X))
>>>
[LOG]: ["z", "f"] 
[LOG]: ["Z", "F"] 

在这种情况下，它与陷阱一起工作(TS让你通过它的数值访问值):

enum X {
  Z,
  F
};

console.log(Object.values(X))
console.log(Object.keys(X))
>>>
[LOG]: ["Z", "F", 0, 1] 
[LOG]: ["0", "1", "Z", "F"] 

因此，根据Enum定义，任何你写在Enum上循环的函数都将工作/失败。这是…不好的。

我的结论是:Enum不是被设计用来作为对象的。如果你需要访问键和值集合，请使用const而不是enum:

const Enumed = {
    X: 1,
    Y: 2
}

Typescript将控制对象键的存在，你将能够使用object。钥匙等，以安全一致的方式。

一个棘手的地方是TypeScript会在触发对象中'double'映射enum，所以它可以通过键和值访问。

enum MyEnum {
    Part1 = 0,
    Part2 = 1
}

将以

{
   Part1: 0,
   Part2: 1,
   0: 'Part1',
   1: 'Part2'
}

所以你应该在映射之前先过滤对象。所以@Diullei的解决方案是正确的。这是我的实现:

// Helper
const StringIsNumber = value => isNaN(Number(value)) === false;

// Turn enum into array
function ToArray(enumme) {
    return Object.keys(enumme)
        .filter(StringIsNumber)
        .map(key => enumme[key]);
}

像这样使用它:

export enum GoalProgressMeasurements {
    Percentage,
    Numeric_Target,
    Completed_Tasks,
    Average_Milestone_Progress,
    Not_Measured
}

console.log(ToArray(GoalProgressMeasurements));

 this worked for me :

    export enum FeedBackType {
    FEEDBACK1= 'FEEDBACK1',
    FEEDBACK2= 'FEEDBACK2',
    FEEDBACK3= 'FEEDBACK3',
    }

----------------------------------------------------------------- 
    export function getTypeFeedBackList() {
    let feedbackList: FeedBackType[] = [];
    Object.keys(FeedBackType).map((key) => {
    let strEnum = key as unknown as FeedBackType;
    feedbackList.push(strEnum);
    });
    return feedbackList;
    }
---------------------------------------------------------------- 
declare this :

    public feedbackList: FeedBackType[] = [];

and after call your function in  :

    ngOnInit(): void {
    this.feedbackList = getTypeFeedBackList();
    console.log(this.feedbackList); 
    }

Happy coding ;) 

设enum变量为:

 enum EnumName {
      A = 1,
      B = 2
    };

那么列表是:

const list = Object.keys(Enum)
.filter((value => isNaN(Number(value)) === false))
      .map(key => ({ id: key, value: Enum[key] }));

list的值为

list = [ 
{ id:1 , value: A },
{ id:2 , value: B },
];

如果你使用的是ES8

只有在这种情况下，它才会工作得很好。它会给你给定枚举的值数组。

enum Colors {
  WHITE = 0,
  BLACK = 1,
  BLUE = 3
}

const colorValueArray = Object.values(Colors); //[ 'WHITE', 'BLACK', 'BLUE', 0, 1, 3 ]

你会得到这样的colorValueArray ['WHITE'， 'BLACK'， 'BLUE'， 0,1,3]。所有的键都在数组的前半部分，所有的值都在数组的后半部分。

甚至这种枚举也可以正常工作

enum Operation {
    READ,
    WRITE,
    EXECUTE
}

但是这种解决方案不适用于这样的异构枚举

enum BooleanLikeHeterogeneousEnum {
  No = 0,
  Yes = "YES",
}