How to get all enum values from a single enum value in typescript?

Question

Here is an enum definition

enum MyNumber {
    ONE='ONE',
    TWO='TWO',
    THREE='THREE',
    FOUR='FOUR',
    FIVE='FIVE',
}

This will print all enum values.

const values = Object.values(MyNumber);
console.log(values); // prints ["ONE", "TWO", "THREE", "FOUR", "FIVE"]

If I'm only given a variable myVar, I know it's an enum value, but I don't know what the actual enum is. Is there a way to infer the enum type and get all possible enum values from this variable myVar?

Have you checked this link: https://stackoverflow.com/questions/18111657/how-to-get-names-of-enum-entries? — Rajesh, Aug 25 '22 at 03:36
You can check this **[fiddle](https://jsfiddle.net/8vsdLt7x/)** for working sample — Rajesh, Aug 25 '22 at 03:43
Thanks for the fiddle, but that's not what I'm asking for. The given condition is that the actual enum MyNumber is unknown. In your fiddle, the function knows about MyNumber — s-hunter, Aug 25 '22 at 03:51

score 1 · Accepted Answer · answered Sep 05 '22 at 11:37

Enums are a TypeScript-only feature, by which I mean, there is no formal definition of an enum in JavaScript. At compile time, the enum itself is erased, and all that is left (for non-const) enums is a simple object; for example...

var MyNumber;
(function (MyNumber) {
    MyNumber["ONE"] = "ONE";
    MyNumber["TWO"] = "TWO";
    MyNumber["THREE"] = "THREE";
    MyNumber["FOUR"] = "FOUR";
    MyNumber["FIVE"] = "FIVE";
})(MyNumber || (MyNumber = {}));

You'll notice there that the object itself, of course has a type (MyNumber), but the members of MyNumber are not of type MyNumber, and this is why you cannot identify the type of an enum from one of its members.

Note: Enums in TypeScript (and even C#) suck! They are just named values, unlike in Java where they are fully qualified objects with enum semantics.

What you could do is implement an enum class, rather than using TypeScript's built-in enum. I've seen this practice used quite a lot in the C# community.

Here is an abstract class for implementing enums...

abstract class Enum {

    protected constructor(public readonly value: number, public readonly name: string) {
    }
    
    public toString(): string {
        return this.name;
    }
    
    public valueOf(): number {
        return this.value;
    }

    public static getAll<T extends Enum>(): T[] {
        const enumeration: {[key:string]:any} = this;
        return Object
            .keys(enumeration)
            .filter(name => enumeration[name] instanceof this)
            .map(name => enumeration[name]);
    }
}

And here is how you would implement it...

class MyNumber extends Enum {
    public static readonly ONE: MyNumber = new MyNumber(1, "ONE");
    public static readonly TWO: MyNumber = new MyNumber(2, "TWO");
    public static readonly THREE: MyNumber = new MyNumber(3, "THREE");
    public static readonly FOUR: MyNumber = new MyNumber(4, "FOUR");
    public static readonly FIVE: MyNumber = new MyNumber(5, "FIVE");

    // Make sure this is private so consumers can't add to or edit your enum!
    private constructor(public readonly value: number, public readonly name: string) {
        super(value, name);
    }
}

And here's a test...

const value = MyNumber.ONE;
const proto: typeof Enum = value.constructor as typeof Enum;

console.log(proto.name);
console.log(proto.getAll());

And the output...

"MyNumber" 

[MyNumber: {
  "value": 1,
  "name": "ONE"
}, MyNumber: {
  "value": 2,
  "name": "TWO"
}, MyNumber: {
  "value": 3,
  "name": "THREE"
}, MyNumber: {
  "value": 4,
  "name": "FOUR"
}, MyNumber: {
  "value": 5,
  "name": "FIVE"
}]

And the playground: Playground

Note: There are some added benefits to this; for example, currently in TypeScript, you can't do T extends enum, but with this approach, you can do T extends Enum.

score 0 · Answer 2 · answered Sep 05 '22 at 10:55

When it comes specifically to TypeScript enums, it is not possible to know from what enum type a value came from. This is because the values of an enum are encoded underneath either as numbers or strings, and do not hold any references to their enum source.

This is more evident when understanding that a (non-const) enum compiles to an object which maps from keys to values and vice versa.

enum MyNumber {
    ONE = 'ONE',
    TWO = 'TWO',
    THREE = 'THREE',
    FOUR = 'FOUR',
    FIVE = 'FIVE',
}

var MyNumber;
(function (MyNumber) {
    MyNumber["ONE"] = "ONE";
    MyNumber["TWO"] = "TWO";
    MyNumber["THREE"] = "THREE";
    MyNumber["FOUR"] = "FOUR";
    MyNumber["FIVE"] = "FIVE";
})(MyNumber || (MyNumber = {}));

Even if the member type is known at compile time, the compiler currently does not provide a type mapping from an enum member to its respective enum type, as of TypeScript v4.8.

If one truly needs to point back to which enum it came from, then one either needs to encode that information alongside the enum value, or use classes instead of enums.

How to get all enum values from a single enum value in typescript?

2 Answers2