Wie konvertiere ich einen String in ein Enum in TypeScript?

Question

Ich habe das folgende Enum in TypeScript definiert:

enum Color{
    Rot, Grün
}

Jetzt erhalte ich in meiner Funktion die Farbe als Zeichenkette. Ich habe den folgenden Code versucht:

var grün = "Grün";
var farbe : Color = grün; // Fehler: kann Zeichenkette nicht in Enum konvertieren

Wie kann ich diesen Wert in ein Enum konvertieren?

Answer 1

Fast alle Antworten verwenden unsichere Typumwandlungen (as oder is). Diese hier nicht:

enum Color {
    Red = "rot",
    Green = "grün"
}

const colorsMap = new Map(Object.values(Color).map((v) => [v,v]))

function parseColor(volumeData: string): Color | undefined {
    return colorsMap.get(volumeData)
}

const color = parseColor("rot")

Answer 2

Für TS 3.9.x

var farbe : Farbe = Farbe[grün as unknown as keyof typeof Farbe];

Answer 3

Wenn Sie mit TypeScript 4.1+ und String-Enums arbeiten und einen einfachen String-zu-Enum-Konverter mit Kompilierzeit- und Laufzeitsicherheit möchten, funktioniert folgendes gut:

export const asEnum = <
  T extends { [key: string]: string },
  K extends keyof T & string
>(
  enumObject: T,
  value: `${T[K]}`
): T[K] => {
  if (Object.values(enumObject).includes(value)) {
    return (value as unknown) as T[K];
  } else {
    throw new Error('Der bereitgestellte Wert wurde nicht im Enum gefunden');
  }
};

enum Test {
  hey = 'HEY',
}

const test1 = asEnum(Test, 'HEY');   // keine Beschwerden hier
const test2 = asEnum(Test, 'HE');    // Kompilierzeitfehler
const test3 = asEnum(Test, 'HE' as any); // Laufzeitfehler

Answer 4

Für Typescript >= 4 hat dieser Code funktioniert:

enum Color{
    Red, Green
}

// Konvertierung:
var green= "Green";
var color : Color = green as unknown as Color;

Answer 5

Enum

enum MyEnum {
    First,
    Second,
    Three
}

Beispielverwendung

const parsed = Parser.parseEnum('FiRsT', MyEnum);
// parsed = MyEnum.First 

const parsedInvalid= Parser.parseEnum('other', MyEnum);
// parsedInvalid = undefined

Ignoriere Groß-/Kleinschreibung beim Parsen

class Parser {
    public static parseEnum(value: string, enumType: T): T[keyof T] | undefined {
        if (!value) {
            return undefined;
        }

        for (const property in enumType) {
            const enumMember = enumType[property];
            if (typeof enumMember === 'string') {
                if (enumMember.toUpperCase() === value.toUpperCase()) {
                    const key = enumMember as string as keyof typeof enumType;
                    return enumType[key];
                }
            }
        }
        return undefined;
    }
}