열거 형 항목의 이름을 얻는 방법?

열거 형 항목의 이름을 얻는 방법?

---

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

이름 만 출력됩니다.

열거 형 멤버 : 바

열거 형 멤버 : 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에서는 형식화 된 열거 형을 사용합니다.

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

이 자바 스크립트 객체의 결과 :

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부터 열거 형은 문자열 intializers를 포함 할 수 있습니다 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에 , 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();

---

enum-values동일한 문제가 발생했을 때 작성한 패키지 를 사용할 수 있습니다 .

힘내 : 열거 형 값

var names = EnumValues.getNames(myEnum);

---

typescript 2.4부터 열거 형에는 더 이상 키가 멤버로 포함되지 않습니다. Typescript readme 소스

주의 사항은 문자열로 초기화 된 열거 형을 역 열거하여 원래 열거 형 멤버 이름을 얻을 수 없다는 것입니다. 다시 말해, 문자열 "Red"를 얻기 위해 Colors [ "RED"]를 작성할 수 없습니다.

내 해결책 :

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

---

위의 일부 답변을 바탕 으로이 유형 안전 함수 서명을 생각해 냈습니다.

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'

실제로보기

---

내가 생각하는 가장 좋은 방법은 원하는 열거 형 값을 선언하는 것입니다. 그런 식으로 접근하는 것은 깨끗하고 예쁘다.

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

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

생산할 것이다 :

VALUE1
VALUE2

---

값이 문자열 인 경우에도 모든 경우에 적합한 유일한 솔루션 은 다음과 같습니다.

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

---

타입 스크립트 문서에 따르면 정적 함수가있는 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 

정적 함수가있는 Enum에 대한 자세한 내용은 아래 링크를 참조하십시오 https://basarat.gitbooks.io/typescript/docs/enums.html

---

열거 형 값으로 유형을 확인하는 EnumUtil 클래스를 작성했습니다.

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

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

사용 방법:

enum TestEnum{
  A= 0,
  B= 1
}

EnumUtils.getEnumKeys(TestEnum, "number");
EnumUtils.getEnumValues(TestEnum, "number");

키 결과 : [ "A", "B"]

값에 대한 결과 : [0, 1]

---

그 솔루션이 더 우아하다는 것을 알았습니다.

for (let val in myEnum ) {

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

다음이 표시됩니다.

bar 
foo

---

내 열거 형은 다음과 같습니다.

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

---

"typescript itumate over enum keys"를 검색하여이 질문을 찾았습니다. 그래서 나는 단지 내 경우에 맞는 솔루션을 게시하고 싶습니다. 어쩌면 누군가에게도 도움이 될 것입니다.

내 경우는 다음과 같습니다. 각 enum 키를 반복 한 다음 일부 키를 필터링 한 다음 enum에서 계산 된 값으로 키가있는 일부 객체에 액세스하려고합니다. 이것이 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]
    }))

---

귀하의 질문에 대한 정확한 답변은 아니지만 문제를 해결하기위한 비결입니다.

export module Gender {

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

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

}

원하는 방식으로 목록 모델을 확장 할 수 있습니다.

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

이제 다음과 같이 사용할 수 있습니다.

for(let gender of Gender.List){
  console.log(gender.Female.key);
  console.log(gender.Female.value);
}

또는:

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

참고 URL : https://stackoverflow.com/questions/18111657/how-to-get-names-of-enum-entries