it-swarm.com.de

Wie erhält man die Namen von TypeScript-Enum-Einträgen?

Ich würde gerne wissen, wie ich eine TypeScript-Enumeration und jeden aufgelisteten Symbolnamen iteriere.

Z.B.,

enum myEnum { entry1, entry2 }

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

Der Code, den Sie gepostet haben, wird funktionieren. Es werden alle Mitglieder der Aufzählung ausgedruckt, einschließlich der Werte der Aufzählungsmitglieder. Zum Beispiel den folgenden Code:

enum myEnum { bar, foo }

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

Druckt Folgendes aus:

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

Wenn Sie stattdessen nur die Mitgliedsnamen und nicht die Werte wünschen, können Sie Folgendes tun:

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

Das druckt nur die Namen aus:

Aufzählungsmitglied: bar 

Enum-Mitglied: foo

Vorsichtsmaßnahme: Dies hängt leicht von einem Implementierungsdetail ab: TypeScript kompiliert Enumerationen in ein JS-Objekt, wobei die Enumerationswerte Mitglieder des Objekts sind. Wenn TS sich entschied, sie in Zukunft anders einzusetzen, könnte die obige Technik brechen.

153

Obwohl die Antwort bereits gegeben ist, wies fast niemand auf die docs

Hier ist ein Ausschnitt

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

Wenn Sie sich an die Regeln halten und nur Aufzählungen mit numerischen Werten erstellen, können Sie diesen Code verwenden. Dies behandelt den Fall korrekt, wenn Sie einen Namen haben, der zufällig eine gültige Nummer ist 

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']
49
Ryan Cavanaugh

Ein einfacher, praktischer und direkter Weg, um zu verstehen, was los ist, ist für mich die folgende Aufzählung:

enum colors { red, green, blue };

Wird im Wesentlichen dazu konvertiert:

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

Aus diesem Grund wird Folgendes zutreffen:

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

Auf diese Weise können Sie den Namen einer Aufzählung auf einfache Weise abrufen:

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

Außerdem wird eine nette Methode zum Konvertieren einer Zeichenfolge in einen Aufzählungswert erstellt.

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

Die beiden oben genannten Situationen sind weitaus häufiger, da Sie sich in der Regel viel mehr für den Namen eines bestimmten Werts und für die generische Serialisierung von Werten interessieren.

37

Wenn Sie nur nach den Namen suchen und später iterieren, verwenden Sie Folgendes:

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

Mit der aktuellen TypeScript Version 1.8.9 verwende ich typisierte Enums:

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

mit Ergebnissen in diesem Javascript-Objekt:

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

also muss ich Schlüssel und Werte abfragen und nur Werte zurückgeben:

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

Und ich erhalte die Optionsschlüssel in einem Array:

optionNames = [ "OPTION1", "OPTION2" ];
19
Philip Miglinci

Diese Lösung funktioniert auch.

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

var type: ScreenType = ScreenType.Edit;

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

Sie können das enum-values-Paket verwenden, das ich geschrieben habe, als ich dasselbe Problem hatte:

Git: enum-values ​​

var names = EnumValues.getNames(myEnum);
10
Slava Shpitalny

Seit TypeScript 2.4 können Enumerationen String-Intializer enthalten https://www.typescriptlang.org/docs/handbook/release-notes/TypeScript-2-4.html

So können Sie schreiben:

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

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

und diese Ausgabe erhalten:

Einer ist der Erste

8
John Huebner

Basierend auf einigen Antworten habe ich diese typsichere Funktionssignatur gefunden:

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

Verwendungszweck:

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

der Typ von stringVals ist 'entry1' | 'entry2'

Sehen Sie es in Aktion

6
Dmitry

Ab TypeScript 2.4 enthält das Enum den Schlüssel nicht mehr als Member. Quelle aus der TypeScript-Readme

Der Nachteil ist, dass Zeichenfolgeninitialisierte Aufzählungen nicht umgekehrt zugeordnet werden können, um den ursprünglichen Namen der Aufzählungsmitglieder zu erhalten. Mit anderen Worten, Sie können Colors ["RED"] nicht schreiben, um die Zeichenfolge "Red" zu erhalten.

Meine Lösung:

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

Lassen Sie ts-enum-util ( github , npm ) die Arbeit für Sie erledigen und stellen Sie viele zusätzliche typsichere Dienstprogramme bereit. Funktioniert sowohl mit Zeichenfolgen als auch mit numerischen Enummen und ignoriert die numerischen Reverse-Lookup-Einträge für numerische Enummen ordnungsgemäß:

String enum:

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

Numerische enum:

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();
5
Jeff Lau

Eine weitere interessante Lösung hier gegründet nutzt 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']
]);

BENUTZEN

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

Laut der TypeScript-Dokumentation können wir dies über Enum mit statischen Funktionen tun.

Erhalte einen Namen mit statischen Funktionen 

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 

um mehr über Enum mit statischer Funktion zu erfahren, folgen Sie dem Link unten https://basarat.gitbooks.io/TypeScript/docs/enums.html

2
Shahid Ahmad

Ich denke am besten, Sie geben einfach die gewünschten Enumerationswerte an. Auf diese Weise ist der Zugriff auf sie sauber und schön (jedes Mal).

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

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

wird herstellen:

VALUE1
VALUE2
2
stemadsen

Ich finde diese Lösung eleganter:

for (let val in myEnum ) {

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

Es zeigt an:

bar 
foo
1

Ich habe eine EnumUtil-Klasse geschrieben, die eine Typüberprüfung anhand des Aufzählungswerts vornimmt:

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

Wie man es benutzt:

enum TestEnum{
  A= 0,
  B= 1
}

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

Ergebnis für Schlüssel: ["A", "B"]

Ergebnis für Werte: [0, 1]

1
Arnold Vakaria

Die einzige Lösung, die für mich in allen Fällen funktioniert (auch wenn Werte Strings sind), ist folgende:

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

Ich fand diese Frage, indem ich nach "TypeScript iterate over enum keys" suchte. Ich möchte also nur eine Lösung posten, die in meinem Fall für mich funktioniert. Vielleicht hilft es auch jemandem.

Mein Fall ist der folgende: Ich möchte über jeden Aufzählungsschlüssel iterieren, dann einige Schlüssel filtern und dann auf ein Objekt zugreifen, das Schlüssel als berechnete Werte aus der Aufzählung enthält. So mache ich das, ohne einen TS-Fehler zu haben.

    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 !== InsuranceType.OSAGO
    )

    const allowedLabels = allowedKeys.map((type) => ({
      label: LABELS[type]
    }))
0
Alendorff

Mein Enum sieht so aus:

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

wenn Sie dies tun, geben Sie undefined zurück:

UserSorting[UserSorting.SortByUpdatedAt]

Um dieses Problem zu beheben, wähle ich einen anderen Weg, um es mit einer Pipe zu tun:

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

Und um es zu benutzen:

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