Typescript enums have been a bane of good development in a lot of my cases.
Take the following enum for example:

enum Result {
  Ok,
  Err
}

In reality, the decompiled typescript results in the following:

var Result;
(function (Result) {
  Result[(Result["Ok"] = 0)] = "Ok";
  Result[(Result["Err"] = 1)] = "Err";
})(Result || (Result = {}));

There’s so much weirdness in this.
Let’s try and parse this.

  1. With the var keyword, it attaches a variable called Result to the global scope[1]
  2. An IIFE is invoked with Result as a paremeter
  3. Result is given the value of Result or {}
  4. Result is given the values of Result["Ok"] = 0, which would give:
[
  {"Ok": 0},
  {"Err": 1}
]

After invoking IIFE, we now are left with the following:

var Result = {}
Result["Ok"] = 0
Result["Err"] = 1

As Result is always given the Symbol.Iterator type, we can loop over Result like so:

Object.entries(Result)

// Returns…


{

Ok: 0,

0: “Ok”,

Err: 1,

1: “Err”,

}

Like, just why would you do this. You’re just left with a bunch of repeating indexes which are, awkward to navigate when actually using these in code.
It’s why I almost never use them and just use a Dicitionary in code instead, as this allows you to join and implement keys from other dictionaries, extend your types and are generally just far more powerful.

  1. The var keyword attaches each variable declared to a global scope, for this reason, it is not recommended ↩︎

Backlinks

No backlinks found.

Go back