Enums considered harmful

Summary

This video discusses the controversial use of TypeScript enums and their peculiar behavior at runtime. The speaker explains why enums, though initially introduced for a C#-like feel, may not be the best choice due to their unpredictable nature and the TypeScript community's shift towards 'as const' objects for type safety and flexibility. The video also touches on the potential of JavaScript adopting enums natively, which could change the current perspective on their usage.

Takeaways

• 📝 TypeScript enums are a feature that has received criticism for not being native to JavaScript and for their unpredictable behavior at runtime.
• 🔄 Enums in TypeScript can be confusing because they don't behave as expected; they map both keys and values to the same object, which can lead to unexpected results when using `Object.values`.
• 🛠 Anders Hejlsberg, the lead architect of TypeScript, has expressed that if TypeScript were being created today, enums might not be included due to their issues.
• 🔑 TypeScript enums can be useful for type safety and refactoring ease, but they require careful handling due to their nominal typing nature, which is unusual for TypeScript's structural type system.
• ⚠️ Using enums can lead to errors, especially when different enums with the same values are used interchangeably, as TypeScript cares about the names of enum members.
• 🌟 'const enums' in TypeScript are a compromise, providing type safety without the runtime object structure, but they have their pitfalls and are not recommended for library code.
• 📚 The TypeScript documentation warns against the use of 'const enums' due to potential issues with compiler control and edge cases.
• 📦 An alternative to enums is using a 'const' annotated plain object (POJO), which provides a cleaner and more flexible approach, aligning with TypeScript's structural typing system.
• 🔄 Using 'as const' objects allows for more flexibility and can represent mappings between semantic keys and their representations, making it a powerful feature for various use cases.
• 🚫 The speaker suggests ignoring enums in favor of 'as const' objects, and even encourages flagging enums in PRs for reconsideration.
• 🔄 If enums were to be included in JavaScript natively, it could change the conversation, as they would be better documented and understood by all JavaScript developers.

Q & A

What is the main topic discussed in the video script?

The main topic discussed in the video script is the use of TypeScript enums, their pros and cons, and whether they should be used or replaced with alternative approaches.

Why do some people criticize TypeScript enums?

Some people criticize TypeScript enums because they behave unpredictably at runtime and are not native to JavaScript, which can lead to confusion and unexpected behavior in code.

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

A regular enum in TypeScript creates an object at runtime with both key-value pairs and reverse mappings, while a const enum only exists at the type level and is stripped out at runtime, providing type safety without a runtime representation.

Why might TypeScript enums be considered a mistake by the language's creators?

The creators of TypeScript might consider enums a mistake because they do not align well with TypeScript's structural typing system and can introduce complexity and confusion in the code.

How do enums behave differently when used as a switch case in TypeScript?

Enums in TypeScript, when used as a switch case, require the use of the enum member with the enum name prefix, such as `logLevel.debug`, rather than just the value `debug`, due to TypeScript's nominal typing for enums.

What are the benefits of using enums for refactoring in TypeScript?

Enums make refactoring easier in TypeScript because they allow for easy renaming and reordering of enum members, which are automatically reflected throughout the code, improving developer efficiency.

What is the recommended alternative to using enums according to the video script?

The video script recommends using a 'const' annotated plain old JavaScript object (POJO) as an alternative to enums, which provides type safety and flexibility without the complexities associated with enums.

Why are const enums considered dangerous in library code?

Const enums are considered dangerous in library code because they can lead to runtime errors if the compiler does not properly handle their inlining, and they can cause confusion due to their absence from the runtime.

How does using 'as const' provide more flexibility compared to enums?

Using 'as const' allows for the creation of objects with keys that can be used directly as types, providing a more natural and flexible way to handle type-safe values without the need for enum declarations and additional mappings.

What is the potential impact of enums being natively included in JavaScript?

If enums were natively included in JavaScript, they would be more predictable and better understood by developers, as they would be a standard part of the language with comprehensive documentation.

What is the presenter's stance on teaching enums in his TypeScript course?

The presenter does not teach enums in his TypeScript course, indicating his low regard for their use and suggesting that they are not essential for mastering TypeScript.