What is a TypeScript enum and when should you use one?

A TypeScript enum is a named set of constants that can be numeric or string-based. String enums are more debuggable (values appear in logs as readable strings) and are preferred over numeric enums in most cases. However, many TypeScript experts recommend using const objects with as const or union types instead, since enums generate runtime code and have surprising behavior around reverse mapping and module augmentation.

What is the difference between a regular enum and a const enum in TypeScript?

Regular enums compile to a JavaScript object that exists at runtime, allowing reverse mapping (Direction[0] === 'Up') and dynamic access. const enums are fully erased at compile time — every usage is replaced with the literal value. Const enums produce smaller bundles but cannot be used dynamically or referenced by name after compilation, making them unsuitable for library code where consumers import the enum.

Why do many TypeScript developers avoid enums?

Enums have several sharp edges: they generate runtime JavaScript code (unlike most TypeScript); numeric enum reverse mapping can produce unexpected values; const enums break when used across declaration file boundaries; and they cannot be extended or iterated safely. The alternatives — union types ('A' | 'B' | 'C') and const objects with as const — provide similar developer ergonomics with fewer surprises and no runtime overhead.

What is the best alternative to TypeScript enums?

The most flexible alternative is a const object with as const combined with a derived union type: const Direction = { Up: 'UP', Down: 'DOWN' } as const; type Direction = typeof Direction[keyof typeof Direction]. This gives you dot-notation access (Direction.Up), string literal union type safety, no runtime overhead beyond the object, and compatibility with string literal unions so both Direction.Up and 'UP' are valid.

TypeScript Enums Explained

Numeric Enums

enum Direction {
  Up,     // 0
  Down,   // 1
  Left,   // 2
  Right,  // 3
}
console.log(Direction.Up)    // 0 console.log(Direction[0])    // 'Up' — reverse mapping exists!
enum Status {   Draft = 1,    // manual start value   Published,    // 2   Archived,     // 3 }

Numeric enums generate both forward (Name → value) and reverse (value → Name) mappings in the compiled output.

String Enums

enum Color {
  Red   = 'RED',
  Green = 'GREEN',
  Blue  = 'BLUE',
}
console.log(Color.Red)   // 'RED' console.log(Color['RED']) // ❌ No reverse mapping — string enums don't have it

String enums are more debuggable (readable values in logs) and don't have the reverse mapping issue of numeric enums. They are more widely recommended.

Const Enums

const enum Weekday {
  Mon = 1, Tue, Wed, Thu, Fri, Sat, Sun
}
const today = Weekday.Mon // Compiles to: const today = 1  — enum is fully inlined, no object emitted

Const enums are erased entirely at compile time — values are inlined wherever they're used. This reduces bundle size but means the enum doesn't exist at runtime. Avoid them in library code where consumers may use the enum by name.

Heterogeneous Enums (Avoid)

// ❌ Don't do this — mixing types is confusing
enum Mixed {
  No = 0,
  Yes = 'YES',
}

The Case Against Enums

Many TypeScript experts recommend using union types instead:

// ❌ Enum approach
enum Direction { Up = 'UP', Down = 'DOWN', Left = 'LEFT', Right = 'RIGHT' }
function move(dir: Direction) { / / }
move(Direction.Up)
// ✅ Union type — simpler, no runtime artifact, more flexible type Direction = 'UP' | 'DOWN' | 'LEFT' | 'RIGHT' function move(dir: Direction) { / / } move('UP')  // direct string — no enum import needed
// ✅ Object with as const — best of both worlds const Direction = {   Up: 'UP',   Down: 'DOWN',   Left: 'LEFT',   Right: 'RIGHT', } as const
type Direction = typeof Direction[keyof typeof Direction]  // 'UP' | 'DOWN' | 'LEFT' | 'RIGHT' move(Direction.Up)  // 'UP' — dot notation like enum move('UP')          // also valid — string literals work too

When to Use Each

| Approach | Use When | |---|---| | Numeric enum | Interop with C# or legacy code, database flags | | String enum | Debuggable runtime values needed, team is familiar with enums | | Const enum | Bundle size critical, no library consumers, no reverse mapping needed | | Union type | New TypeScript code, no runtime artifact needed, simple cases | | const object + typeof | Need dot notation AND string literals to work, maximum flexibility |

The TypeScript team itself uses const objects with as const extensively in their own codebase.

Practice TypeScript questions at [JSPrep Pro](/auth).

TypeScript Enums Explained: Numeric, String & Const Enums