Enums, and what they compile to

Almost everything TypeScript adds is erased. Enums are the main exception: an enum declaration compiles to a real JavaScript object, and that object is what your code reads at runtime.

enum Status { Draft, Live, Archived }        // 0, 1, 2
enum Region { Europe = "eu", Asia = "asia" }

Members of a numeric enum count up from 0 unless you give them values (Low = 1, Medium, High gives 1, 2, 3).

The reverse mapping

For a numeric enum the compiler emits both directions — name to number and number back to name — into the same object. A string enum gets only the forward direction:

1enum Status {2  Draft,3  Live,4  Archived,5}6 7enum Region {8  Europe = "eu",9  Asia = "asia",10}11 12export function run(): unknown[] {13  return [14    Status.Live,              // the value15    Status[1],                // reverse mapping: number back to name16    Object.keys(Status),      // a numeric enum holds both directions17    Object.keys(Region),      // a string enum holds names only18    Object.values(Region),19  ];20}

That is handy for logging (Status[s] turns 1 back into "Live"), and a trap for anything that walks the object: Object.keys(Status) has six entries, not three, and half of them are the numbers as strings.

Checking a value from outside

A string arriving in a request must be checked before it is treated as a member. Because of the reverse mapping, name in Status and Status[name] !== undefined both accept "1" (and in also accepts inherited keys such as "toString"). Two checks together are safe: the key is the object's own property (Object.hasOwn), and the value found under it has the type the members have (a number, for a numeric enum — the reverse entries hold strings).

The alternatives

Many codebases skip enums for a union of string literals, or for an object marked as const with a type derived from its values. Both are plain JavaScript at runtime, with no reverse mapping to trip over:

1const Status = {2  Draft: "draft",3  Live: "live",4  Archived: "archived",5} as const;6 7// The union of the values: "draft" | "live" | "archived".8type Status = (typeof Status)[keyof typeof Status];9 10function isStatus(value: string): value is Status {11  return (Object.values(Status) as string[]).includes(value);12}13 14export function run(): unknown[] {15  return [Object.values(Status), isStatus("live"), isStatus("deleted"), Object.isFrozen(Status)];16}

as const makes every property readonly and every value its literal type, so (typeof Status)[keyof typeof Status] is the union "draft" | "live" | "archived". It does not freeze the object; that would be Object.freeze.

A const enum is meant to be erased, with each use replaced by its value. That inlining needs to read the declaration, which may live in another file; tools that compile one file at a time do not have it, so projects built with them (and libraries, whose users may use such tools) usually avoid const enum.

Common mistakes

• Object.values on a numeric enum. You get the names and the numbers, six entries for three members.
• Validating with in or a plain lookup. The reverse mapping makes "1" look like a member name, and in accepts inherited keys.
• Relying on numeric values that may shift. Inserting a member in the middle renumbers everything after it. Store explicit values when the numbers leave the process (a database column, an API).
• Treating as const as runtime protection. It is checked by the compiler only.

What interviewers ask