एनम प्रविष्टियों के नाम कैसे प्राप्त करें?

Question

मैं एक टाइपस्क्रिप्ट enumटाइप करना चाहता हूं और प्रत्येक नामांकित प्रतीक नाम प्राप्त करना चाहता हूं , जैसे:

enum myEnum { entry1, entry2 }

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

Comments

इस छोटे से getAllEnumValuesgetAllEnumKeys

— एनम

Answer 1

आपके द्वारा पोस्ट किया गया कोड काम करेगा; यह enum के सभी सदस्यों को प्रिंट करेगा, जिसमें enum सदस्यों के मान भी शामिल होंगे। उदाहरण के लिए, निम्न कोड:

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

यह सिर्फ नाम छपेगा:

एनम सदस्य: बार

एनुम सदस्य: फू

कैविएट: यह थोड़ा कार्यान्वयन विवरण पर निर्भर करता है: टाइपस्क्रिप्ट एनस ऑब्जेक्ट के सदस्य होने के साथ जेएस ऑब्जेक्ट के लिए एनमों को संकलित करता है। यदि टीएस ने भविष्य में उन्हें अलग से लागू करने का निर्णय लिया, तो उपरोक्त तकनीक टूट सकती है।

Comments

स्पष्ट होने के लिए, उपरोक्त उत्तर अभी भी टीएस 2.3 के रूप में काम करता है। हालांकि, यदि आप "एनम एनम" का उपयोग करते हैं, केवल "एनम" के बजाय, तब ही यह काम नहीं करेगा। Const enum का उपयोग मूल रूप से TS को खोज-और-प्रतिस्थापन करने के लिए कह रहा है; हर स्थान पर आप MyEnum का उपयोग करते हैं। फिर, इसे एक समान संख्यात्मक मान से प्रतिस्थापित किया जाएगा।

— जुदा गेब्रियल हिमंगो

मुझे लगता है कि +enumMember >= 0होना चाहिए isFinite(+enumMember)क्योंकि नकारात्मक या अस्थायी बिंदु मूल्यों को रिवर्स मैप भी मिलता है। ( खेल का मैदान )

— स्पेंसेरी

Answer 2

हालांकि जवाब पहले से ही प्रदान किया गया है, लगभग किसी ने इशारा नहीं किया डॉक्स की

यहाँ एक स्निपेट है

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

ध्यान रखें कि स्ट्रिंग एनम सदस्यों को रिवर्स मैपिंग उत्पन्न नहीं होती है।

Comments

इसमें यह भी कहा गया है कि "ध्यान रखें कि स्ट्रिंग एनम सदस्यों को रिवर्स मैपिंग उत्पन्न नहीं होती है।"

— jbojcic

इस प्रदर्शन से 0या प्रदर्शन के बारे में कैसे 1? export enum Octave { ZERO = 0, ONE = 1 }

— स्टीफन

@jbojcic क्या यह स्थिति के बारे में है enum Enum {"A"}; let nameOfA = Enum[Enum.A];:? जैसा कि टाइपस्क्रिप्ट@2.9.2 के अनुसार यह मेरे लिए ठीक काम करता है ...

— 18

मूल्यों के माध्यम से लूपिंग के बारे में कैसे?

— शिओको

Answer 3

मान लें कि आप नियमों से चिपके रहते हैं और केवल संख्यात्मक मानों के साथ एनम का उत्पादन करते हैं, तो आप इस कोड का उपयोग कर सकते हैं। यह सही ढंग से उस मामले को संभालता है जहां आपके पास एक नाम है जो संयोग से एक वैध संख्या है

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

Comments

चेतावनी आधुनिक टाइपस्क्रिप्ट (tsc 2.5.2 atm) में आपको शुरू करने के लिए एक कुंजी के रूप में एक संख्यात्मक स्ट्रिंग रखने की अनुमति नहीं है। जैसा कि हिमांगो का जवाब बेहतर है, क्योंकि यह सभी मामलों को कवर करता है और इसमें कोई गिरावट नहीं है।

— 9

Answer 4

मेरे लिए यह समझने का एक आसान, व्यावहारिक और प्रत्यक्ष तरीका है कि निम्नलिखित गणना क्या है:

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

उपरोक्त दो स्थितियां कहीं अधिक सामान्य स्थिति हैं, क्योंकि आमतौर पर आप एक विशिष्ट मूल्य और उदारतापूर्वक मूल्यों को क्रमबद्ध करने के नाम पर अधिक रुचि रखते हैं।

Answer 5

यदि आप केवल नामों की खोज करते हैं और बाद में इसका उपयोग करते हैं:

Object.keys(myEnum).map(key => myEnum[key]).filter(value => typeof value === 'string') as string[];

Comments

या ES2017 परिवाद के साथ:Object.values(myEnum).filter(value => typeof value === 'string') as string[];

— कोई भी

मुझे एक तानाशाह बनाने की जरूरत थी, और मैंने एक जवाब के रूप में आपके जवाब का इस्तेमाल किया। अगर किसी और को इसकी आवश्यकता है,Object.values(myEnum).filter(value => typeof value === 'string').map(key => { return {id: myEnum[key], type: key }; });

— Fejs

Answer 6

वर्तमान टाइपस्क्रिप्ट संस्करण 1.8.9 के साथ मैं टाइप किए गए Enums का उपयोग करता हूं:

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

Answer 7

टाइपस्क्रिप्ट 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()}`);

और यह उत्पादन प्राप्त करें:

एक फर्स्ट है

Answer 8

यह समाधान भी काम करता है।

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

var type: ScreenType = ScreenType.Edit;

console.log(ScreenType[type]); //Edit

Answer 9

यहां पाया गया एक और दिलचस्प समाधान ES6 मैप का उपयोग कर रहा है:

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

Answer 10

आज्ञा देना 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();

Answer 11

टाइपस्क्रिप्ट 2.4 से शुरू करते हुए, एनम में एक सदस्य के रूप में कुंजी नहीं होगी। टाइपस्क्रिप्ट रीडमे से स्रोत

चेतावनी यह है कि मूल-आरंभ सदस्य नाम प्राप्त करने के लिए स्ट्रिंग-इनिशियेटेड एनम को रिवर्स मैप नहीं किया जा सकता है। दूसरे शब्दों में, आप स्ट्रिंग "रेड" पाने के लिए कलर्स ["RED"] नहीं लिख सकते।

मेरा समाधान:

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

Answer 12

enum-valuesजब मैंने वही समस्या की थी तो आप मेरे द्वारा लिखे गए पैकेज का उपयोग कर सकते हैं :

Git: enum-values

var names = EnumValues.getNames(myEnum);

Comments

आप वास्तव में सवाल का जवाब नहीं दे रहे हैं, कोड / आदि के साथ अपने उत्तर का दस्तावेजीकरण करना बेहतर होगा लेकिन मुझे पैकेज उपयोगी नहीं लगा।

— लुकामा

Answer 13

ऊपर दिए गए कुछ उत्तरों के आधार पर मैं इस प्रकार के सुरक्षित फंक्शन सिग्नेचर के साथ आया:

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'

इसे एक्शन में देखें

Comments

इसके (keyof T)[]बजाय समारोह वापस आ जाना चाहिए keyof T। साथ ही, exportआपके खेल के मैदान को काम करने से रोकता है।

— जोएल

Answer 14

ऐसा लगता है कि यहाँ कोई भी उत्तर -मोड में स्ट्रिंग-एनम के साथ काम नहीं करेगा strict।

एनम पर विचार करें:

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]

Comments

keyofसाथ उपयोग करने के लिए शानदार समाधान typeof! अन्य समाधान बहुत अपारदर्शी लगता है, लेकिन आखिरकार मुझे लगता है कि टाइपस्क्रिप्ट को DX पर सुधार करने की आवश्यकता है - Enum के लिए डेवलपर अनुभव

— Shaung Cheng

Answer 15

मुझे लगता है कि सबसे अच्छा तरीका सिर्फ वांछित एनम मूल्यों की घोषणा करना है। इस तरह से उन तक पहुंचना स्वच्छ और सुंदर है (हर बार)।

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

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

उत्पादन करेंगे:

VALUE1
VALUE2

Answer 16

टाइपस्क्रिप्ट दस्तावेज़ीकरण के अनुसार, हम Enum के माध्यम से स्थैतिक कार्यों के साथ ऐसा कर सकते हैं।

स्थिर कार्यों के साथ 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/sums.html

Answer 17

एकमात्र समाधान जो मेरे लिए सभी मामलों में काम करता है (भले ही मूल्य स्ट्रिंग हों) निम्नलिखित हैं:

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

Answer 18

पुराना प्रश्न, लेकिन, 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]

Comments

अगर सही गलत है तो मुझे सही करें लेकिन console.log(Object.keys(Foo))पहले उदाहरण में ही वापस आता है ["BAR", "EVERYTHING_IS_TERRIBLE"]..

— पीटर

@ खिलाड़ी ts खेल के मैदान पर यहाँ एक नज़र दे , बस कंसोल खोलें और रन पर क्लिक करें। कम से कम मेरे लिए, यह प्रिंट करता है["60", "80", "BAR", "EVERYTHING_IS_TERRIBLE"]

— गेब्रियल डी ओलिवेरा रोहडेन

यह आपका अधिकार प्रतीत होता है, मजेदार बात यदि आप संख्याओं से बदलकर तार आप उत्पादन की उम्मीद करते हैं, तो मुझे पता नहीं है कि टाइपस्क्रिप्ट स्ट्रिंग में संख्याओं और संख्याओं को अलग-अलग तरीके से क्यों संभालती है ..

— पीटर

Answer 19

मुझे यह सवाल "टाइपस्क्रिप्ट इटर्म ओवर एनम कीज़" की खोज से मिला। इसलिए मैं बस समाधान पोस्ट करना चाहता हूं जो मेरे मामले में मेरे लिए काम करता है। शायद यह किसी को भी मदद करेगा।

मेरा मामला निम्नलिखित है: मैं प्रत्येक एनम कुंजी पर पुनरावृति करना चाहता हूं, फिर कुछ कुंजियों को फ़िल्टर करें, फिर कुछ ऑब्जेक्ट तक पहुंचें, जिसमें एनी से गणना किए गए मान के रूप में चाबियाँ हैं। तो यह है कि कैसे मैं इसे किसी भी 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]
    }))

Answer 20

मैंने एक EnumUtil क्लास लिखी है, जो enum value के द्वारा एक प्रकार की जाँच कर रही है:

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 के लिए परिणाम: ["ए", "बी"]

StringValueEnumvalues ​​के परिणाम: ["A", "B"]

Answer 21

मुझे लगता है कि समाधान अधिक सुरुचिपूर्ण है:

for (let val in myEnum ) {

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

यह प्रदर्शित करता है:

bar 
foo

Answer 22

मेरी एनम इस तरह है:

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

इसलिए यह वापसी अपरिभाषित है :

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

Answer 23

अगर आपको एनम है

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

Comments

यह एक त्रुटि का कारण बनता है: Argument of type '(d: Diet) => void' is not assignable to parameter of type '(value: string, index: number, array: string[]) => void'. Types of parameters 'd' and 'value' are incompatible. Type 'string' is not assignable to type 'MyEnum'.(2345)

— मरोड़ना

Answer 24

मैंने एक एनुमर को लिखने के लिए एक हेल्पर फंक्शन लिखा:

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
}

फ़ंक्शन कुछ ऐसा देता है जिसे आसानी से एनुमरेट किया जा सकता है, और एनम प्रकार को भी डाली जाती है।

Answer 25

एक मौजूदा संस्करण टाइपस्क्रिप्ट का उपयोग करके आप एनुम को अपने चयन के रिकॉर्ड में मैप करने के लिए इन जैसे कार्यों का उपयोग कर सकते हैं। ध्यान दें कि आप इन फ़ंक्शन के साथ स्ट्रिंग मानों को परिभाषित नहीं कर सकते हैं क्योंकि वे एक संख्या वाले मान के साथ कुंजियों की तलाश करते हैं।

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

Answer 26

यहां पहले से ही बहुत सारे उत्तर हैं, लेकिन मुझे लगता है कि मैं अपना समाधान वैसे भी ढेर पर फेंक दूंगा।

टाइपस्क्रिप्ट खेल का मैदान

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" 👍
 */

टाइपस्क्रिप्ट रिकॉर्ड के लिए संदर्भ

एक अच्छा सहायक कार्य:

const getAccountTypeName = (type: AccountType) => {
  return reversed[type]
};

// getAccountTypeName(AccountType.Twitter) === 'Twitter'

Answer 27

आपके द्वारा उपयोग किए जाने वाले enum मानों की सूची प्राप्त करने के लिए:

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

Object.values(AnimalEnum);

Answer 28

यह आपके सवाल का बिल्कुल जवाब नहीं है लेकिन यह आपकी समस्या से निपटने की एक चाल है।

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.");
}