TypeScript枚举转换为对象数组

只需一行：

Object.entries(GoalProgressMeasurements).map(([key, value]) => ({id: key, value: value}))

另一种方法是使用ES8 Object.entries

export enum Weeks {  
    MONDAY = 1,  
    TUESDAY= 2,  
    WEDNESDAY = 3,  
    THURSDAY = 4,  
    FRIDAY = 5,  
    SATURDAY=6,  
    SUNDAY=7,  
}


function convertEnumToArray(){
   const arrayObjects = []            
     // Retrieve key and values using Object.entries() method. 
     for (const [propertyKey, propertyValue] of Object.entries(Weeks)) { 

      // Ignore keys that are not numbers
      if (!Number.isNaN(Number(propertyKey))) {  
        continue;  
      }  

      // Add keys and values to array
      arrayObjects.push({ id: propertyValue, name: propertyKey });  
    }        

  console.log(arrayObjects); 
}

将产生以下结果：

[ 
  { id: 1, name: 'MONDAY' },  
  { id: 2, name: 'TUESDAY' },  
  { id: 3, name: 'WEDNESDAY' },  
  { id: 4, name: 'THURSDAY' },  
  { id: 5, name: 'FRIDAY' },  
  { id: 6, name: 'SATURDAY' },  
  { id: 7, name: 'SUNDAY' } 
] 

不要脸地从这个博客偷了过来

首先我们获取该枚举的键数组。然后，使用map()函数将数据转换为所需的格式。id从键中获取，名称从相同的键的枚举中获取。

const converted = Object.keys(GoalProgressMeasurements).map(key => {
        return {
            id: GoalProgressMeasurements[key],
            name: key,
        };
    });

我希望您不要在需要枚举条目列表的情况下使用TS Enums。

在运行时，枚举被实现为对象，但仅在以下情况下才按您期望的方式工作：

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

任何你编写的用于循环枚举的函数都将根据枚举定义工作/失败。这...不太好。
我的结论：枚举不是为了被用作对象而设计的。如果需要访问键和值集合，请使用const代替enum：

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

Typescript将控制对象键的存在性，并且您可以以安全和一致的方式执行Object.keys等操作。

export function enumKeys(E: any): string[] {
    return Object.keys(E).filter(k => isNaN(Number(k)));
}

export function enumValues(E: any): string[] | number[] {
    return enumKeys(E).map(k => E[k as any]);
}

适用于以下两种情况：

enum TestA {
    RED = "red",
    BLUE = "blue"
}

enum TestB {
    ONE = 1,
    TWO = 2
}

我已经解决了，方法如下。 假设你有一个像下面这样的枚举。

export enum UnitEnum {
  GRAM = 'gm',
  KILOGRAM = 'kg',
  LITRE = 'lt',
  CENTIMETER = 'cm',
  INCH = 'in',
  METER = 'mt',
  KILOMETER = 'km',
}

而且，你有一个像这样的类：

export interface Unit {
  Name: string;
  Symbol: string;
}

然后，您可以创建一个函数，如下所示，将异构枚举映射到特定类型的对象：

export function getDefaultUnits() {
  const myUnits = Object.entries(UnitEnum).map(x => {
    return { Name: x[0], Symbol: x[1] } as Unit
  })

  console.log(myUnits);

  return myUnits;
}

我只学了几个月的Typescript，下面的解决方案适用于我。希望它也能帮助其他人 -

export enum ScheduleType {
  Basic = <any>'B',
  Consolidated = <any>'C',
}

scheduleTypes = Object.keys(ScheduleType)
.filter((k, i) => i % 2)
.map((key: any) => {
  return {
    systemValue: key,
    displayValue: ScheduleType[key],
  };
});

它给出了以下结果 - [{displayValue: "基础", systemValue: "B"}, {displayValue: "综合", systemValue: "C"}]

有一个简单的解决方案，当你运行Object.keys(Enum)时，它会给你一个值和键的数组，在第一个切片中是值，在第二个切片中是键，那么为什么我们不只返回第二个切片呢？下面的代码对我有效。

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

让枚举变量为：

 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 = [ 
{ id:1 , value: A },
{ id:2 , value: B },
];