How To Java

Enums

Introduction

Enums in TypeScript offer a powerful way to define a set of named constants, making your code more readable and less error-prone. By using enums, you can ensure that variables are only assigned valid, predefined values. This is particularly useful in scenarios like setting directions, days of the week, or user roles, where only specific values are allowed.

What is an Enum?

An enum, short for "enumeration," is a custom data type that allows you to define a collection of related values. Each value in an enum is assigned a unique identifier, which can either be a number or a string.

Defining a Basic Enum

Let's start with a simple example. Imagine you need to represent the four cardinal directions in your code. Instead of using plain strings or numbers, you can define an enum:

enum Direction {
  North,
  South,
  East,
  West
}

Here, Direction is an enum that represents four possible values: North, South, East, and West. These values are the only options that a variable of type Direction can hold.

Working with Enums Once you've defined an enum, you can use it just like any other type in TypeScript. For example:

let travelDirection: Direction;

travelDirection = Direction.North; // Valid
travelDirection = Direction.West;  // Also valid
travelDirection = "South";         // Error: "South" is not part of the Direction enum

In this example, the variable travelDirection can only be assigned one of the enum values, ensuring that your code remains consistent and type-safe.

How TypeScript Assigns Values

By default, TypeScript assigns numeric values to each enum member, starting from 0:

Direction.North; // 0
Direction.South; // 1
Direction.East;  // 2
Direction.West;  // 3

If needed, you can use these numeric values directly:

travelDirection = 2; // This corresponds to Direction.East

Customizing Enum Values

TypeScript also allows you to assign custom numeric values to enum members:

enum Direction {
  North = 10,
  South = 20,
  East = 30,
  West = 40
}

Now, each direction has a specific value:

Direction.North; // 10
Direction.South; // 20
Direction.East;  // 30
Direction.West;  // 40

This flexibility lets you align enum values with other data structures or systems where specific values are required.

Using String Enums

In addition to numeric enums, TypeScript supports string enums, which can make your code more descriptive and easier to debug:

enum Status {
  Active = "ACTIVE",
  Inactive = "INACTIVE",
  Pending = "PENDING"
}

With string enums, each member has a meaningful name:

let userStatus: Status = Status.Active; // No more guessing what the number represents!

String enums are especially useful when working with data that is displayed in UI elements or stored in databases.

Enum vs. Tuples

While enums are great for named constants, remember that tuples (covered earlier) serve a different purpose—they group together related values of different types. Use enums when you need a fixed set of possible values for a variable, and tuples when you need to bundle together different types of data.

String Enums VS Numeric Enums

Enums in TypeScript come in two main flavors: numeric enums and string enums. Both types of enums allow you to create a set of named constants, but they behave differently and are used in distinct scenarios. Let's explore how each type works and when you might prefer one over the other.

Numeric Enums

Numeric enums, the type we've seen so far, are based on numbers. By default, TypeScript assigns numeric values starting from 0 to each enum member:

enum DirectionNumber {
  North,
  South,
  East,
  West
}

In this case, DirectionNumber.North will be 0, DirectionNumber.South will be 1, and so on. You can also manually set the values if needed:

enum DirectionNumber {
  North = 10,
  South = 20,
  East = 30,
  West = 40
}

One potential drawback with numeric enums is that they allow direct assignment of numbers, even if they don't correspond to any valid enum member:

let direction: DirectionNumber;
direction = 1;  // This is valid, but it might not be what you intended.
direction = 943205; // Also valid, but likely a mistake.

This flexibility can introduce bugs into your code if you're not careful.

String Enums

String enums, on the other hand, are much more restrictive and require you to explicitly define the string values for each member:

enum DirectionString {
  North = "NORTH",
  South = "SOUTH",
  East = "EAST",
  West = "WEST"
}

With string enums, you cannot directly assign arbitrary strings to an enum variable. This ensures that only valid, predefined values are used:

let direction: DirectionString;
direction = "SOUTH"; // Type error: This is not allowed!
direction = DirectionString.South; // Correct usage

String enums offer better type safety and make your code more readable, as the values themselves convey meaningful information. For example, error messages or logs that include "SOUTH" are easier to understand than those showing a number like 1.

Why Prefer String Enums?

In general, string enums are often recommended over numeric enums because they:

Enhance Readability: String values are more descriptive and easier to interpret in code, error messages, and logs.
Prevent Bugs: By disallowing direct assignment of arbitrary values, string enums reduce the chances of accidental errors.
Consistency: The explicit nature of string enums ensures that your code remains consistent and predictable.

While numeric enums can be useful in specific cases—such as when you need to interact with systems that expect numeric codes—string enums are generally safer and more intuitive for most applications.

Conclusion

In summary, both numeric and string enums have their place in TypeScript. Numeric enums offer flexibility but come with risks, while string enums prioritize clarity and safety. When deciding which to use, consider the specific needs of your project and the trade-offs between flexibility and type safety.

By understanding the differences between these two types of enums, you'll be better equipped to make informed decisions in your TypeScript projects.

Custom Types

Object Types