Enum member access in Typescript

Introduction

Enums help group related values under one name. Accessing enum members lets you use these values clearly and safely in your code.

When you want to represent a fixed set of options like days of the week.

When you need readable names for numeric or string constants.

When you want to avoid using 'magic numbers' or strings scattered in your code.

When you want to check or compare values against a known set.

When you want to improve code clarity and reduce errors.

Syntax

Typescript

enum EnumName {
  Member1,
  Member2 = 5
}

// Access enum member
EnumName.Member1
EnumName[0]  // for numeric enums

Enum members can be numbers or strings.

Numeric enums have reverse mapping: you can get name from value.

Examples

Accessing numeric enum member by name.

Typescript

enum Direction {
  Up,
  Down,
  Left,
  Right
}

let move = Direction.Up;

Enum with custom numeric values.

Typescript

enum Status {
  Success = 1,
  Failure = 0
}

let result = Status.Success;

String enum members accessed by name.

Typescript

enum Color {
  Red = "RED",
  Green = "GREEN",
  Blue = "BLUE"
}

let favorite = Color.Green;

Accessing enum member name by numeric value (reverse mapping).

Typescript

enum Direction {
  Up,
  Down
}

let name = Direction[0];

Sample Program

This program uses enum member access to decide what action to take for each traffic light color.

Typescript

enum TrafficLight {
  Red = "RED",
  Yellow = "YELLOW",
  Green = "GREEN"
}

function getAction(light: TrafficLight): string {
  switch (light) {
    case TrafficLight.Red:
      return "Stop";
    case TrafficLight.Yellow:
      return "Get Ready";
    case TrafficLight.Green:
      return "Go";
  }
}

console.log(getAction(TrafficLight.Red));
console.log(getAction(TrafficLight.Yellow));
console.log(getAction(TrafficLight.Green));

Important Notes

Use enum member names to avoid mistakes with raw values.

String enums do not have reverse mapping like numeric enums.

Accessing enum members by name is safer and clearer than using raw values.

Summary

Enums group related values under one name.

Access enum members using dot notation: EnumName.Member.

Numeric enums support reverse mapping; string enums do not.