Як програмно перерахувати тип переліку?

90

Скажімо , у мене є машинопис enum, MyEnumнаступним чином :

enum MyEnum {
    First,
    Second,
    Third
}

Який найкращий спосіб у TypeScript 0.9.5 створити масив enumзначень? Приклад:

var choices: MyEnum[]; // or Array<MyEnum>
choices = MyEnum.GetValues(); // plans for this?
choices = EnumEx.GetValues(MyEnum); // or, how to roll my own?
enums  typescript 
— Девід Кучча
джерело

Відповіді:

192

Це вихід JavaScript цього переліку:

var MyEnum;
(function (MyEnum) {
    MyEnum[MyEnum["First"] = 0] = "First";
    MyEnum[MyEnum["Second"] = 1] = "Second";
    MyEnum[MyEnum["Third"] = 2] = "Third";
})(MyEnum || (MyEnum = {}));

Що є таким об’єктом:

{
    "0": "First",
    "1": "Second",
    "2": "Third",
    "First": 0,
    "Second": 1,
    "Third": 2
}

Учасники Enum із рядковими значеннями

TypeScript 2.4 додав можливість перерахувань, можливо, мати значення члена перерахування рядка. Тож можна закінчити з переліком, який виглядає так:

enum MyEnum {
    First = "First",
    Second = 2,
    Other = "Second"
}

// compiles to
var MyEnum;
(function (MyEnum) {
    MyEnum["First"] = "First";
    MyEnum[MyEnum["Second"] = 2] = "Second";
    MyEnum["Other"] = "Second";
})(MyEnum || (MyEnum = {}));

Отримання імен членів

Ми можемо поглянути на приклад безпосередньо вище, щоб спробувати з’ясувати, як отримати учасників переліку:

{
    "2": "Second",
    "First": "First",
    "Second": 2,
    "Other": "Second"
}

Ось що я придумав:

const e = MyEnum as any;
const names = Object.keys(e).filter(k => 
    typeof e[k] === "number"
    || e[k] === k
    || e[e[k]]?.toString() !== k
);

Цінність членів

Одного разу, у нас є імена, ми можемо прокрутити їх, щоб отримати відповідне значення, виконавши:

const values = names.map(k => MyEnum[k]);

Клас розширення

Я думаю, що найкращий спосіб зробити це - створити власні функції (наприклад EnumEx.getNames(MyEnum)). Ви не можете додати функцію до переліку.

class EnumEx {
    private constructor() {
    }

    static getNamesAndValues(e: any) {
        return EnumEx.getNames(e).map(n => ({ name: n, value: e[n] as string | number }));
    }

    static getNames(e: any) {
        return Object.keys(e).filter(k => 
            typeof e[k] === "number"
            || e[k] === k
            || e[e[k]]?.toString() !== k
        );
    }

    static getValues(e: any) {
        return EnumEx.getNames(e).map(n => e[n] as string | number);
    }
}
— Девід Шеррет
джерело
Цікаво (оскільки багато людей підтримали цю відповідь), я не можу змусити це працювати в TS Playground: shorturl.me/jJ8G2t Чи я роблю щось не так?
— Петро
1
@Peter Я оновив відповідь, включивши інформацію про перелічення рядків. Крім того, ви захочете використовувати for ofзаяву замістьfor in
— Девід Шеррет,
24

За допомогою TypeScript> = 2.4 ви можете визначити перелічення рядків:

enum Color {
  RED = 'Red',
  ORANGE = 'Orange',
  YELLOW = 'Yellow',
  GREEN = 'Green',
  BLUE = 'Blue',
  INDIGO = 'Indigo',
  VIOLET = 'Violet'
}

Вихід JavaScript ES5:

var Color;
(function (Color) {
    Color["RED"] = "Red";
    Color["ORANGE"] = "Orange";
    Color["YELLOW"] = "Yellow";
    Color["GREEN"] = "Green";
    Color["BLUE"] = "Blue";
    Color["INDIGO"] = "Indigo";
    Color["VIOLET"] = "Violet";
})(Color || (Color = {}));

Що є таким об’єктом:

const Color = {
  "RED": "Red",
  "ORANGE": "Orange",
  "YELLOW": "Yellow",
  "GREEN": "Green",
  "BLUE": "Blue",
  "INDIGO": "Indigo",
  "VIOLET": "Violet"
}

Таким чином, у випадку перерахування рядків, немає необхідності фільтрувати речі, Object.keys(Color)і Object.values(Color)(*) достатньо:

const colorKeys = Object.keys(Color) as (keyof typeof Color)[];
console.log('colorKeys =', colorKeys);
// ["RED", "ORANGE", "YELLOW", "GREEN", "BLUE", "INDIGO", "VIOLET"]

const colorValues = Object.values(Color);
console.log('colorValues =', colorValues);
// ["Red", "Orange", "Yellow", "Green", "Blue", "Indigo", "Violet"]

colorKeys.map(colorKey => {
  console.log(`color key = ${colorKey}, value = ${Color[colorKey]}`);
});
/*
color key = RED, value = Red
color key = ORANGE, value = Orange
color key = YELLOW, value = Yellow
color key = GREEN, value = Green
color key = BLUE, value = Blue
color key = INDIGO, value = Indigo
color key = VIOLET, value = Violet
*/

Див. Приклад в Інтернеті на майданчику TypeScript

(*) Polyfill необхідний для старих браузерів, див. Https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_objects/Object/values#Browser_compatibility

— tanguy_k
джерело
У цьому є помилкаElement implicitly has an 'any' type because expression of type 'string' can't be used to index type 'typeof Color'. No index signature with a parameter of type 'string' was found on type 'typeof Color'.
— Йонас,
1
@Jonas Я виправив це за допомогою акторського складу:Object.keys(Color) as (keyof typeof Color)[]
— tanguy_k
чудово, дякую!
— Йонас,
9

Ви можете додати функції, щоб отримати імена та індекси переліку:

enum MyEnum {
  First,
  Second,
  Third
}

namespace MyEnum {
  function isIndex(key):boolean {
    const n = ~~Number(key);
    return String(n) === key && n >= 0;
  }

  const _names:string[] = Object
      .keys(MyEnum)
      .filter(key => !isIndex(key));

  const _indices:number[] = Object
      .keys(MyEnum)
      .filter(key => isIndex(key))
      .map(index => Number(index));

  export function names():string[] {
    return _names;
  }

  export function indices():number[] {
    return _indices;
  }
}

console.log("MyEnum names:", MyEnum.names());
// Prints: MyEnum names: ["First", "Second", "Third"]

console.log("MyEnum indices:", MyEnum.indices());
// Prints: MyEnum indices: [0, 1, 2]

Зверніть увагу, що ви могли б просто експортувати _namesта _indicesconsts, а не виставляти їх за допомогою експортованої функції, але оскільки експортовані члени є членами перерахування, можливо, зрозуміліше мати їх як функції, щоб їх не плутали з фактичними членами перерахування.

Було б непогано, якби TypeScript згенерував щось подібне автоматично для всіх перерахувань.

— Багатий
джерело
7

Немає поняття RTTI (інформація про тип виконання) у TypeScript (подумайте: відображення), тому для цього потрібно знання перекладеного JavaScript. Отже, припускаючи TypeScript 0,95:

enum MyEnum {
    First, Second, Third
}

стає:

var MyEnum;
(function(MyEnum) {
    MyEnum[MyEnum["First"] = 0] = "First";
    MyEnum[MyEnum["Second"] = 1] = "Second";
    MyEnum[MyEnum["Third"] = 2] = "Third";
}

Отже, це змодельовано як звичайний об'єкт у javascript, де MyEnum.0 == "First"і MyEnum.First == 0. Отже, щоб перерахувати всі імена перечислення, вам потрібно отримати всі властивості, які належать об’єкту і які також не є числами:

for (var prop in MyEnum) {         
    if (MyEnum.hasOwnProperty(prop) &&
        (isNaN(parseInt(prop)))) {
        console.log("name: " + prop);
    }
}

Гаразд, отже, тепер я розповів вам, як це зробити, дозволено сказати, що це погана ідея . Ви не пишете керованою мовою, тому не можете використовувати ці звички. Це все ще звичайний старий JavaScript. Якби я хотів використовувати структуру в JavaScript для заповнення списку вибору, я б використовував звичайний старий масив. Перерахування тут не є правильним вибором. Метою TypeScript є створення ідіоматичного, симпатичного JavaScript. Використання перелічень таким чином не зберігає цілі.

— x0n
джерело
5

Я використав рішення, запропоноване Девідом Шерретом, і написав бібліотеку npm, яку ви можете використовувати з назвою enum-values...

Git: значення переліку

// Suppose we have an enum
enum SomeEnum {
  VALUE1,
  VALUE2,
  VALUE3
}

// names will be equal to: ['VALUE1', 'VALUE2', 'VALUE3']
var names = EnumValues.getNames(SomeEnum);

// values will be equal to: [0, 1, 2]
var values = EnumValues.getValues(SomeEnum);
— Слава Шпитальний
джерело
3

Однорядковий рядок для отримання списку записів (об’єкти / пари ключ-значення):

Object.keys(MyEnum).filter(a=>a.match(/^\D/)).map(name=>({name, value: MyEnum[name] as number}));
— Венрікс
джерело
2 
enum MyEnum {
    First, Second, Third, NUM_OF_ENUMS
}

for(int i = 0; i < MyEnum.NUM_OF_ENUMS; ++i) {
    // do whatever you need to do.
}
— Джо
джерело
5
Це працює лише в тому випадку, якщо ваш перелік не визначає жодних значень (він добре упакований та збільшується). Наприклад, значення перерахування можуть бути "First = 0x1000" або "PageNotFound = 404". NUM_OF_ENUMS завжди буде на один більший за найбільше визначене значення, тому 0x1001 або 405 у моїх прикладах.
— Аку
2

Якщо ви хочете пов’язати значення рядків із вашим переліченням, ці методи не працюють. Щоб мати загальну функцію, ви можете зробити:

function listEnum(enumClass) {
    var values = [];
    for (var key in enumClass) {
        values.push(enum[key]);
    }
    values.length = values.length / 2;
    return values;
}

Це працює, оскільки TypeScript на першому кроці додасть ключі, а на другому - значення.

У TypeScript це:

var listEnums = <T> (enumClass: any): T[]=> {
    var values: T[] = [];
    for (var key in enumClass) {
        values.push(enumClass[key]);
    }
    values.length = values.length / 2;
    return values;
};

var myEnum: TYPE[] = listEnums<TYPE>(TYPE);
— Чкланг
джерело
1

Відповідь Джо просто змусив мене зрозуміти, що набагато простіше покладатися на перші N числових клавіш, ніж робити більш складні тестування:

function getEnumMembers(myEnum): string[]
{
    let members = []
    for(let i:number = 0; true; i++) {
        if(myEnum[i] === undefined) break
        members.push(myEnum[i])
    }

    return members
}

enum Colors {
    Red, Green, Blue
}

console.log(getEnumMembers(myEnum))
— кбц
джерело
4
Це небезпечне припущення, оскільки можна визначити значення, присвоєні перерахуванням, і вони не повинні бути додатковими та добре упакованими. Нерідко можна побачити бітові маски в переліченні, наприклад, або, можливо, у таблиці кодів помилок HTML, які починаються з 400.
— Aku,
— Хуан Мендес,
0

для nodejs:

const { isNumber } = require('util');

Object.values(EnumObject)
      .filter(val => isNumber(val))
      .map(val => {
         // do your stuff
      })
— Suben Saha
джерело
0

Ітерація над переліком

Для цього найкраще використовувати String Enums. Ось приклад:

// This is a string enum
enum MyEnum {
    First = 'First',
    Second = 'Second',
    Third = 'Third',
}

// An enum is a TS concept
// However his MyEnum compiles to JS object:
//  {
//   "First": "First",
//   "Second": "Second",
//   "Third": "Third"
// } 


// Therefore we can get the keys in the following manner:
const keysArray = Object.keys(MyEnum);

for (const key of keysArray) {
    console.log(key)
}
// [LOG]: "First" 
// [LOG]: "Second" 
// [LOG]: "Third"
— Віллем ван дер Він
джерело
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.