TypeScript Enums

What Are Enums?

Enumerations, commonly known as enums are a feature found in programming languages that allow developers to establish a collection of named values. Enums prove helpful when representing a fixed array of values that remain constant. Than resorting to random numeric or string representations enums offer the ability to assign meaningful labels to predetermined choices. This approach enhances code clarity and manageability by simplifying the comprehension and manipulation of defined values. Through the use of enums developers can steer clear of utilizing unauthorized values thereby ensuring greater reliability in the codebase. Additionally enums often offer a mechanism, for cycling through their specified values further bolstering their practicality.

Why Use Enums in TypeScript?

Enums in TypeScript offer several benefits and practical applications. They allow developers to define a set of named constants, improving code readability. Instead of using arbitrary values, developers can refer to these named constants, making the code more understandable. Enums also help reduce the chance of using invalid values, as any attempt to use a value outside the defined set results in a compilation error. This catches errors early, ensuring that only valid values are used. Additionally, enums enhance type safety, allowing the TypeScript compiler to provide auto-completion and type-checking support, reducing runtime errors and bugs.

Numeric Enums

Numeric enums allow developers to assign number values to each enum member. This provides flexibility in representing different states or categories.

Enum Values

Enum values, also known as named constant values, are predefined within an enumeration. They represent a discrete set of possible choices.

Examples of enum values:

• Gender:
  • Male
  • Female
  • Other
• Days of the Week:
  • Monday
  • Tuesday
  • Wednesday
  • Thursday
  • Friday
  • Saturday
  • Sunday
• Colors:
  • Red
  • Blue
  • Green
  • Yellow
• Seasons:
  • Spring
  • Summer
  • Autumn
  • Winter

Enum values provide a clear way to represent a fixed set of options. They help reduce errors by restricting the available choices and provide a consistent way to refer to specific options.

Reverse Mapping

Reverse mapping in TypeScript enums allows users to obtain information about a specific enum value using its name or value. This feature helps convert a given set of coordinates or addresses into meaningful information about the location. Reverse mapping enables users to map enum values back to their names, providing a convenient way to look up an enum member's name given its value.

Example:‍


enum Direction {
    North,
    South,
    East,
    West,
}

let dir = Direction.North;
let nameOfDirection = Direction[dir]; // "North"

Using Numeric Constants

Using numeric constants improves code readability and maintainability. Numeric constants are fixed values that do not change during program execution.

To use numeric constants effectively:

1. Identify and define the numeric constants required.
2. Declare the numeric constants using meaningful variable names.
3. Initialize the numeric constants with appropriate values.
4. Use the constants throughout the program instead of hardcoding values.

Common numeric constants:

• Math-related: PI (3.14), E (2.71828)
• Physical: SPEED_OF_LIGHT (299,792,458 m/s), GRAVITY (9.8 m/s^2)
• Color-related: BLACK (0x000000), WHITE (0xFFFFFF)

String Enums

String enums allow defining a restricted set of string values. They assign string values as identifiers, making the code more readable.

Example of declaring string enums:‍


enum Colors {
    Red = "RED",
    Blue = "BLUE",
    Green = "GREEN",
    Yellow = "YELLOW",
}

Enums provide a straightforward way to document intent and create distinct cases within programs. They enhance clarity by using meaningful names instead of magic numbers or arbitrary strings. Enums can also have different types of constant values, such as integers, characters, strings, or custom types, making them adaptable for various scenarios.

Heterogeneous Enums

TypeScript enums can be heterogeneous, containing both string and numeric values. However, mixing these types is generally not recommended, as it can lead to confusion and inconsistencies.

Using String Literals

String literals allow using direct string values, simplifying debugging by eliminating the need for number lookup. While string enums provide more descriptive values, they can increase memory usage and introduce typos, making them less efficient.

Union Enums

Union Enums allow a variable to hold different types of values, enabling flexible data structures and simplifying coding logic. Union types combine multiple types into one, allowing any of those types as the variable's value.

Combining Enum Types

In TypeScript, combining enum types uses a special subset called literal enum members. By combining types with the union operator (|), the type system creates a union of each enum member. This helps catch bugs and provides additional type safety by ensuring that only valid enum values are used.

Union of String Values

A union of string values combines multiple string types into one, providing flexibility in handling variables with different string values. However, union types lack the type safety of enums, making enums the recommended choice for a fixed set of values.

Const Enums

Const enums offer improved performance by being removed during compilation, which leads to faster execution. They make code more self-explanatory and eliminate the need for runtime lookups.

Example of using const enums:

const enum Colors {
    Red,
    Green,
    Blue,
}

let color: Colors = Colors.Green;