Enums

The plain-language idea

enum Status {
  Pending,   // 0
  Active,    // 1
  Closed,    // 2
}

function describe(s: Status) {
  if (s === Status.Active) return "active";
}

Unlike almost every other TypeScript-only construct (interfaces, type aliases, generics), an enum isn't erased at compile time — it compiles down to a real JavaScript object at runtime (roughly { Pending: 0, Active: 1, ..., 0: "Pending", 1: "Active", ... } for a numeric enum). That reverse mapping and the extra generated code is unusual for TypeScript, and it's the root of most enum criticism.

The increasingly common alternative

const Status = {
  Pending: "pending",
  Active: "active",
  Closed: "closed",
} as const;

type Status = (typeof Status)[keyof typeof Status];  // "pending" | "active" | "closed"

This "as-const object" pattern gives you the same named-constants experience with zero extra runtime code beyond the object itself — no reverse mapping, and the resulting type is a plain union of string literals, which plays more predictably with the rest of the type system than an enum's own distinct type does.

enum Status { Active, Paused, Done } — compiles to a real JS object at runtime, not erased like other types.

BackNext

What people usually miss

Watch out

• Numeric enums are bidirectionally mapped by default — Status[0] gives you "Pending" back, code most people don't expect exists until they see it in the compiled output.
• String enums don't get reverse mapping, and are usually the safer choice of the two if you do use enum — the runtime values are the actual string names, not sequential numbers that shift if you reorder members.
• This is genuinely one of TypeScript's most debated features — recognizing both the appeal (named constants, exhaustiveness checks) and the real criticism (extra runtime code, less composable than a union type) is a stronger answer than picking a side reflexively.

Why this matters in interviews

"Enum, or a union of string literals?" is a real, live debate in the TypeScript community, and being able to articulate the actual tradeoff (runtime cost and reverse mapping vs. named-group ergonomics) shows practical experience, not just textbook syntax knowledge.