Enums, short for "enumerations," are a feature in TypeScript that allow developers to define a set of named constants. In Angular, enums are particularly useful for managing related values in a structured, organized way. For example, enums can help streamline code related to user roles, statuses, or other types that might otherwise clutter your app with standalone constants. This blog will walk you through creating, using, and effectively applying enums in Angular.

Why Use Enums?

Enums help keep code clean, readable, and maintainable by grouping related constants together. Using enums, you can avoid "magic numbers" or "magic strings" in your code (hard-coded values that can make understanding logic challenging), making the intent of your code clearer. Instead of wondering what status === 1 represents, you can use a named constant like Status.Active, improving code readability and maintainability.

Declaring an Enum

In TypeScript, you can define an enum in two main ways: with numeric values or with string values.

Numeric Enum

A numeric enum uses numbers as its values and will automatically increment each value by one unless specified otherwise:

export enum Role {
  Admin = 1,
  User,
  Guest
}

In this example:

• Admin is assigned a value of 1.
• User is automatically assigned 2, and Guest is assigned 3.

String Enum

String enums allow you to assign string values to each constant, making the code more readable when using specific states, types, or identifiers.

export enum Status {
  Active = 'Active',
  Inactive = 'Inactive',
  Pending = 'Pending'
}

With this approach, the values are clearly descriptive.

Using Enums in Angular Components

Once defined, you can use enums within your Angular components, services, or modules. Enums can help you set default values, check conditions, or manage options within your application. Here’s how to use the Status enum in an Angular component.

Importing and Applying Enums

To use an enum, import it into your component, then define a property that utilizes it:

import { Status, Role } from './path/to/enum';

@Component({
  selector: 'app-user',
  templateUrl: './user.component.html'
})
export class UserComponent {
  userStatus: Status = Status.Active; // Set a default value
  userRole: Role = Role.User;

  checkUserStatus() {
    if (this.userStatus === Status.Active) {
      console.log("User is active");
    }
  }
}

Here, userStatus is initialized with Status.Active, and checkUserStatus checks if the user’s status is Active. This approach keeps your code clean, as you can directly reference Status.Active instead of a hard-coded string or number.

Using Enums in Angular Templates

Enums are also useful in Angular templates, but because templates don’t directly understand enums, you’ll need to expose them from your component. Here’s how you can display content conditionally based on enum values in the template:

Step 1: Expose the Enum in the Component

To access enums in the template, make the enum available as a public property of the component:

import { Status } from './path/to/enum';

@Component({
  selector: 'app-user',
  templateUrl: './user.component.html'
})
export class UserComponent {
  Status = Status; // Expose the enum to the template
  userStatus: Status = Status.Active;
}

Step 2: Use Enum in the Template

Now you can use Status.Active, Status.Inactive, etc., directly in your template with Angular's binding syntax:

<div *ngIf="userStatus === Status.Active">User is active</div>
<div *ngIf="userStatus === Status.Inactive">User is inactive</div>
<div *ngIf="userStatus === Status.Pending">User is pending approval</div>

Populating Dropdowns with Enum Values

Enums are a perfect fit for select dropdowns when you need to present a set of options. Here’s how you can use an enum to populate a dropdown list dynamically in Angular.

Step 1: Extract Enum Values

Convert the enum into an array of its values using Object.values() and then bind it to a dropdown in the template.

statusList = Object.values(Status);

Step 2: Set Up the Dropdown in the Template

With statusList bound to the dropdown, each option will display an enum value.

<select [(ngModel)]="userStatus">
  <option *ngFor="let status of statusList" [value]="status">
    {{ status }}
  </option>
</select>

When to Use Enums

Consider using enums when:

• You have a fixed set of related constants.
• You want to improve code readability.
• You’re dealing with options that require well-defined identifiers, like user roles, permissions, or statuses.

Enums might not be ideal for situations where values are dynamic or come from an API since these would change frequently and are typically better handled by external data sources.

Conclusion

Enums are a valuable tool for managing related constants in Angular applications. They make code easier to read and maintain, and they work well across components, templates, and services. Whether you’re setting up conditional logic, populating dropdowns, or managing application states, enums provide a structured, clean way to handle fixed sets of values.