Come ottenere i nomi delle voci enum?

Vorrei iterare un TypeScript un enumtipo e ottenere ogni nome di simbolo elencato, ad esempio:

enum myEnum { entry1, entry2 }

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

Il codice che hai pubblicato funzionerà; stamperà tutti i membri dell'enum, inclusi i valori dei membri dell'enum. Ad esempio, il seguente codice:

enum myEnum { bar, foo }

for (var enumMember in myEnum) {
   console.log("enum member: ", enumMember);
}

Stampa quanto segue:

Enum member: 0
Enum member: 1
Enum member: bar
Enum member: foo

Se invece desideri solo i nomi dei membri e non i valori, potresti fare qualcosa del genere:

for (var enumMember in myEnum) {
   var isValueProperty = parseInt(enumMember, 10) >= 0
   if (isValueProperty) {
      console.log("enum member: ", myEnum[enumMember]);
   }
}

Che stamperà solo i nomi:

Membro Enum: bar

Membro Enum: foo

Avvertenza: questo si basa leggermente su un dettaglio di implementazione: TypeScript compila gli enum in un oggetto JS con i valori enum che sono membri dell'oggetto. Se TS decidesse di implementarli in modo diverso in futuro, la suddetta tecnica potrebbe rompersi.

Sebbene la risposta sia già fornita, quasi nessuno ha indicato i documenti

Ecco uno snippet

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

Tieni presente che i membri di enum string non ottengono affatto una mappatura inversa.

Supponendo di attenersi alle regole e produrre solo enumerazioni con valori numerici, è possibile utilizzare questo codice. Questo gestisce correttamente il caso in cui si dispone di un nome che è per coincidenza un numero valido

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

Per me un modo più semplice, pratico e diretto per capire cosa sta succedendo, è la seguente enumerazione:

enum colors { red, green, blue };

Sarà convertito essenzialmente in questo:

var colors = { red: 0, green: 1, blue: 2,
               [0]: "red", [1]: "green", [2]: "blue" }

Per questo motivo, sarà vero quanto segue:

colors.red === 0
colors[colors.red] === "red"
colors["red"] === 0

Questo crea un modo semplice per ottenere il nome di un elenco come segue:

var color: colors = colors.red;
console.log("The color selected is " + colors[color]);

Crea anche un modo piacevole per convertire una stringa in un valore enumerato.

var colorName: string = "green";
var color: colors = colors.red;
if (colorName in colors) color = colors[colorName];

Le due situazioni precedenti sono molto più comuni, perché di solito sei molto più interessato al nome di un valore specifico e alla serializzazione dei valori in modo generico.

Se cerchi solo i nomi e esegui iterazioni successive, usa:

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

Con l'attuale TypeScript versione 1.8.9 uso Enum tipizzati:

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

con risultati in questo oggetto Javascript:

Option = {
    "OPTION1": "this is option 1",
    "OPTION2": "this is option 2",
    "this is option 1": "OPTION1",
    "this is option 2": "OPTION2"
}

quindi devo interrogare chiavi e valori e restituire solo valori:

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

E ricevo le chiavi delle opzioni in un array:

optionNames = [ "OPTION1", "OPTION2" ];

A partire dal dattiloscritto 2.4, enumerazioni possono contenere intializers stringa https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-4.html

Questo ti permette di scrivere:

 enum Order {
      ONE = "First",
      TWO = "Second"
 }

console.log(`One is ${Order.ONE.toString()}`);

e ottieni questo output:

Uno è il primo

Anche questa soluzione funziona.

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

var type: ScreenType = ScreenType.Edit;

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

Un'altra soluzione interessante trovata qui sta usando 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']
]);

USO

console.log(TypeLabel.get(Type.low)); // Low Season

Let ts-enum-util( github , npm ) faccia il lavoro per te e fornisca molte altre utility di sicurezza. Funziona con enumerazioni sia a stringa che numeriche, ignorando correttamente le voci di ricerca inversa dell'indice numerico per enumerazioni numeriche:

Enum di stringa:

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 numerico:

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

A partire da TypeScript 2.4, l'enum non conterrà più la chiave come membro. sorgente dal file Leggimi di TypeScript

L'avvertenza è che gli enum inizializzati da stringa non possono essere mappati in senso inverso per ottenere il nome del membro enum originale. In altre parole, non puoi scrivere Colors ["RED"] per ottenere la stringa "Red".

La mia soluzione:

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

Puoi usare il enum-valuespacchetto che ho scritto quando ho avuto lo stesso problema:

Git: enum-valori

var names = EnumValues.getNames(myEnum);

Sulla base di alcune risposte sopra ho escogitato questa firma della funzione di sicurezza:

export function getStringValuesFromEnum<T>(myEnum: T): keyof T {
  return Object.keys(myEnum).filter(k => typeof (myEnum as any)[k] === 'number') as any;
}

Uso:

enum myEnum { entry1, entry2 };
const stringVals = getStringValuesFromEnum(myEnum);

il tipo di stringValsè'entry1' | 'entry2'

Guardalo in azione

Sembra che nessuna delle risposte qui funzionerà con enumerazioni di stringa in strictmodalità.

Considera enum come:

enum AnimalEnum {
  dog = "dog", cat = "cat", mouse = "mouse"
}

Accedendo a questo con AnimalEnum["dog"] può causare un errore come:

Element implicitly has an 'any' type because expression of type 'any' can't be used to index type 'typeof AnimalEnum'.ts(7053).

Soluzione corretta per quel caso, scrivilo come:

AnimalEnum["dog" as keyof typeof AnimalEnum]

Il modo migliore penso sia semplicemente dichiarare i valori enum desiderati. In questo modo accedervi è pulito e carino (ogni volta).

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

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

produrrà:

VALUE1
VALUE2

Secondo la documentazione di TypeScript, possiamo farlo tramite Enum con funzioni statiche.

Ottieni il nome Enum con funzioni statiche

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 

per maggiori informazioni su Enum con funzione statica segui il link seguente https://basarat.gitbooks.io/typescript/docs/enums.html

L'unica soluzione che funziona per me in tutti i casi (anche se i valori sono stringhe) è la seguente:

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

Vecchia domanda, ma perché non usare una constmappa di oggetti?

Invece di fare questo:

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]

Fai questo (presta attenzione al as constcast):

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]

Ho trovato questa domanda cercando "TypeScript iterate over enum keys". Quindi voglio solo pubblicare una soluzione che funzioni per me nel mio caso. Forse aiuterà anche qualcuno.

Il mio caso è il seguente: voglio scorrere su ogni chiave enum, quindi filtrare alcune chiavi, quindi accedere ad un oggetto che ha le chiavi come valori calcolati da enum. Quindi è così che lo faccio senza errori 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]
    }))

Ho scritto una classe EnumUtil che sta effettuando un controllo del tipo in base al valore enum:

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

Come usarlo:

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

Risultato per le chiavi NumberValueEnum: ["A", "B"]

Risultato per i valori NumberValueEnum: [0, 1]

Risultato per StringValueEnumkeys: ["A", "B"]

Risultato per StringValueEnumvalues: ["A", "B"]

Trovo questa soluzione più elegante:

for (let val in myEnum ) {

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

Visualizza:

bar 
foo

Il mio Enum è così:

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

così facendo questo ritorno indefinito :

UserSorting[UserSorting.SortByUpdatedAt]

Per risolvere questo problema, scelgo un altro modo per farlo utilizzando una pipe:

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

E per usarlo:

return this.enumKeyPipe.transform(UserSorting, [UserSorting.SortByUpdatedAt]);

Se hai enum

enum Diet {
  KETO = "Ketogenic",
  ATKINS = "Atkins",
  PALEO = "Paleo",
  DGAF = "Whatever"
}

Quindi puoi ottenere chiave e valori come:

Object.keys(Diet).forEach((d: Diet) => {
  console.log(d); // KETO
  console.log(Diet[d]) // Ketogenic
});

Ho scritto una funzione di supporto per enumerare un enum:

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

Uso:

for (const enumValue of getEnumValues<myEnum>(myEnum)) {
  // do the thing
}

La funzione restituisce qualcosa che può essere facilmente enumerato e si lancia anche nel tipo enum.

Utilizzando una versione corrente di TypeScript è possibile utilizzare funzioni come queste per mappare l'Enum su un record di propria scelta. Si noti che non è possibile definire i valori di stringa con queste funzioni in quanto cercano chiavi con un valore che è un numero.

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

Ci sono già molte risposte qui, ma immagino che lancerò comunque la mia soluzione sulla pila.

Parco giochi TypeScript

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

Per chiarezza:

/*
 * reversed == {
 *   "goo": "Google",
 *   "boo": "Facebook",
 *   "wit": "Twitter",
 * }
 * reversed[AccountType.Google] === "Google" 👍
 */

Riferimento per Record TypeScript

Una bella funzione di aiuto:

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

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

Per ottenere l'elenco dei valori enum devi usare:

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

Object.values(AnimalEnum);

Non è esattamente la risposta alla tua domanda, ma è un trucco per affrontare il tuo problema.

export module Gender {

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

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

}

È possibile estendere il modello di elenco nel modo desiderato.

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

Ora puoi usarlo in questo modo:

for(const gender of Gender.List){
  console.log(gender.name);
  console.log(gender.value);
}

o:

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