TypeScript enums: use cases and alternatives

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.