TypeScript enums: use cases and alternatives

Original Article ↗ Hacker News Discussion ↗

TypeScript’s `enum` feature is increasingly seen as a legacy construct that conflicts with modern tooling and runtime trends, such as Node’s ability to execute TypeScript by stripping types without transforming syntax. Many developers now favor string literal unions plus `as const` objects or helper utilities, which avoid generating runtime code, fit better with TypeScript’s structural type system, and interoperate cleanly across packages. Others still defend enums as clearer and more familiar, especially for nominally typed or numeric constants, but even proponents acknowledge quirks, potential runtime pitfalls, and hints that enums are effectively (if unofficially) deprecated.

Overall sentiment on TypeScript enums

  • Many commenters consider TS enums an anti-pattern or “de-facto deprecated.”
  • Main view: they made sense early in TS’s history but are now largely superseded by newer language features.
  • A minority strongly defend enums as simple, practical, and widely used in real-world codebases without noticeable issues.

Runtime code and Node / “type-stripping” compatibility

  • Enums generate runtime JS code, unlike most TS types, which are erased.
  • With Node 23+ and other runtimes (Deno, Bun) supporting “strip types and run TS,” code using enums, namespaces, legacy modules, and parameter properties breaks unless additional transforms or experimental flags are enabled.
  • Some argue this is already a concrete reason to avoid enums; others say relying on this emerging, partly experimental ecosystem is premature.

Type-system characteristics and quirks

  • Enums are nominally typed, while most of TS is structurally typed.
  • This can cause compatibility issues across packages (e.g., same enum from different versions not assignable to each other).
  • People report confusing behaviors and bugs around inference and imports, especially in large codebases.
  • Pro-enum voices counter that such problems are rare in typical usage.

Common alternatives to enums

  • String union types: type Status = "Active" | "Inactive"; favored for simplicity, exhaustiveness checks, and good editor support.
  • as const object patterns:
    • Basic: const Status = { Active: "Active", Inactive: "Inactive" } as const; type Status = typeof Status[keyof typeof Status];
    • Variants using Record, ValueOf helpers, or utility functions like makeEnum / stringEnum.
  • These patterns preserve runtime values, support type guards, and avoid enum-specific pitfalls, at the cost of more verbose syntax.

Remaining niche uses for enums

  • Some rely on const enum for compile-time constants (e.g., build-time env switches) where no bundler is available.
  • Others prefer enums for readability, documentation on each member, and familiar “Java-style” usage, especially with numeric enums.

Tooling, flags, and “unofficial deprecation”

  • Various tsconfig flags (isolatedModules, verbatimModuleSyntax, proposed erasableSyntaxOnly) and eslint rules push away from enums and namespaces toward erasable-only constructs.
  • Several commenters claim enums and namespaces were early mistakes and should be formally deprecated, but TypeScript’s strong backward-compatibility stance makes outright removal unlikely.