What are enums and when should you use them?

Question

Accepted Answer

An **enum** defines a set of named constants. TypeScript has numeric and string enums.

```ts
enum Direction { Up, Down, Left, Right } // numeric: Up=0, Down=1, ...
Direction.Up;        // 0
Direction[0];        // "Up" — numeric enums have a reverse mapping

enum Status {        // string enum — more readable values
  Active = "ACTIVE",
  Inactive = "INACTIVE",
}
Status.Active;       // "ACTIVE"
```

## A caveat: enums generate runtime code

Unlike most TypeScript types (which vanish at compile time), a regular `enum` emits a JavaScript object into your bundle. That's why many teams prefer a **union of string literals** plus `as const`, which is purely type-level:

```ts
// often preferred — zero runtime cost, easy to read in logs
const Status = { Active: "ACTIVE", Inactive: "INACTIVE" } as const;
type Status = typeof Status[keyof typeof Status]; // "ACTIVE" | "INACTIVE"

// or simply:
type Direction = "up" | "down" | "left" | "right";
```

## const enum

```ts
const enum E { A, B } // inlined at compile time — no runtime object, but has tooling caveats
```

## Why it matters

Enums give meaningful names to fixed sets (states, roles, directions) and group them under one namespace.

But because they emit runtime code and have quirks (numeric enums are loosely checked), modern TypeScript often favors **string-literal unions** for simple cases — they're lighter and serialize naturally.

Use enums when you want the namespacing or reverse mapping.