enums - switch - typescript enum tips




Comment obtient-on les noms des entrées enum TypeScript? (9)

Je voudrais savoir comment itérer une énumération TypeScript et chaque nom de symbole énuméré.

Par exemple,

enum myEnum { entry1, entry2 }

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

À partir du typecript 2.4, l'énumération ne contiendrait plus la clé en tant que membre. source du Readme de Typescript

La mise en garde est que les énumérations initialisées par des chaînes ne peuvent pas être mappées en inverse pour obtenir le nom de membre d'enum d'origine. En d'autres termes, vous ne pouvez pas écrire Colors ["RED"] pour obtenir la chaîne "Red".

Ma solution:

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

Avec la version 1.8.9 actuelle de TypeScript, j'utilise des Enums typés:

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

avec des résultats dans cet objet Javascript:

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

donc je dois interroger à travers les clés et les valeurs et seulement retourner des valeurs:

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

Et je reçois les clés d'option dans un tableau:

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

Cette solution fonctionne aussi.

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

var type: ScreenType = ScreenType.Edit;

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

En supposant que vous respectiez les règles et produisiez uniquement des énumérations avec des valeurs numériques, vous pouvez utiliser ce code. Cela gère correctement le cas où vous avez un nom qui est par coïncidence un nombre valide

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

La seule solution qui fonctionne pour moi dans tous les cas (même si les valeurs sont des chaînes) est la suivante:

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

Laissez ts-enum-util ( github , npm ) faire le travail pour vous et fournir un grand nombre d'utilitaires supplémentaires de type sécurisé. Fonctionne avec les énumérations numériques et numériques, en ignorant correctement les entrées de recherche inversée d'index numérique pour les énumérations numériques:

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

Numérique 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();

Pour moi, une façon plus simple, pratique et directe de comprendre ce qui se passe, est-ce l'énumération suivante:

enum colors { red, green, blue };

Sera converti essentiellement à ceci:

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

Pour cette raison, ce qui suit sera vrai:

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

Cela crée un moyen facile d'obtenir le nom d'un énuméré comme suit:

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

Il crée également un moyen agréable de convertir une chaîne en une valeur énumérée.

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

Les deux situations ci-dessus sont une situation beaucoup plus courante, car vous êtes généralement beaucoup plus intéressé par le nom d'une valeur spécifique et par la sérialisation des valeurs d'une manière générique.


Si vous recherchez uniquement les noms et itérez plus tard, utilisez:

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

Vous pouvez utiliser le paquet enum-values j'ai écrit quand j'ai eu le même problème:

Git: valeurs enum

var names = EnumValues.getNames(myEnum);




typescript