我不认为顺序是可以保证的，否则就很容易切片Object的后半部分。条目的结果和映射来自那里。

上述答案的唯一(非常小的)问题是

字符串和数字之间有很多不必要的类型转换。 当一次迭代同样干净有效时，条目将迭代两次。

type StandardEnum = { [id: string]: number | string; [nu: number]: string;}

function enumToList<T extends StandardEnum> (enm: T) : { id: number; description: string }[] {
    return Object.entries(enm).reduce((accum, kv) => {
        if (typeof kv[1] === 'number') {
            accum.push({ id: kv[1], description: kv[0] })
        }
        return accum
    }, []) // if enum is huge, perhaps pre-allocate with new Array(entries.length / 2), however then push won't work, so tracking an index would also be required
}

有一个简单的解决方案，当你运行object。Keys (Enum)它会给你一个值和键的数组，在第一个slice Values中，在第二个slice key中，为什么我们不直接返回第二个slice，下面的代码对我来说是有用的。

enum Enum {
   ONE,
   TWO,
   THREE,
   FOUR,
   FIVE,
   SIX,
   SEVEN
}
const keys = Object.keys(Enum); 
console.log(keys.slice(keys.length / 2));

一个棘手的地方是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));

我使用

Object.entries(GoalProgressMeasurement).filter(e => !isNaN(e[0]as any)).map(e => ({ name: e[1], id: e[0] }));

一条简单的线就可以做到这一点。

它只需要3个简单的步骤 -使用Object.entries加载键和值的组合。 -过滤掉非数字(因为typescript会为反向查找生成值)。 -然后我们将它映射到我们喜欢的数组对象。

我不喜欢上面的答案，因为它们都不能正确地处理字符串/数字的混合，可以在TypeScript enum中作为值。

下面的函数遵循TypeScript枚举的语义，给出键到值的正确映射。从那里，获取一个对象数组或者仅仅是键或者仅仅是值是很简单的。

/**
 * Converts the given enum to a map of the keys to the values.
 * @param enumeration The enum to convert to a map.
 */
function enumToMap(enumeration: any): Map<string, string | number> {
  const map = new Map<string, string | number>();
  for (let key in enumeration) {
      //TypeScript does not allow enum keys to be numeric
      if (!isNaN(Number(key))) continue;

      const val = enumeration[key] as string | number;

      //TypeScript does not allow enum value to be null or undefined
      if (val !== undefined && val !== null)
          map.set(key, val);
  }

  return map;
}

使用示例:

enum Dog {
    Rover = 1,
    Lassie = "Collie",
    Fido = 3,
    Cody = "Mutt",
}

let map = enumToMap(Dog); //Map of keys to values

let objs = Array.from(map.entries()).map(m => ({id: m[1], name: m[0]})); //Objects as asked for in OP
let entries = Array.from(map.entries()); //Array of each entry
let keys = Array.from(map.keys()); //An array of keys
let values = Array.from(map.values()); //An array of values

我还要指出OP是逆向思考枚举的。枚举中的“键”在技术上是在左边，而值在右边。TypeScript允许你尽可能多地重复RHS上的值。

设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 },
];