Enums & Constants

The "magic value" problem

Suppose an order's status is just a string. Now order.status = "shippd" is a perfectly valid line of code — it compiles, it runs, and it silently puts your order into a state that doesn't exist. Magic values share the same three weaknesses:

• Typos slip through. "shippd", "Shipped", and "SHIPPED" are three different strings to the computer, but you meant one state.
• No autocomplete, no discoverability. Your editor can't suggest the valid options because nothing declares what they are.
• No exhaustiveness. Add a new state later and the compiler can't point you at the twelve switch statements that now miss a case.

An enum is a closed set of named constants

Declaring an enum gives those options names and makes them the only values the type can hold. Assigning anything else is now a compile error, not a runtime surprise. Each member is a first-class value you refer to by name:

enum OrderStatus {
  Pending,
  Paid,
  Shipped,
  Delivered,
  Cancelled,
}

let status: OrderStatus = OrderStatus.Pending;
status = OrderStatus.Shipped;   // ok — a real member
// status = "shippd";           // compile error — not part of the set

Enums can carry data and behavior

In richer languages an enum member isn't just a label — each constant can carry its own fields and even methods. Picture each OrderStatus knowing its own customer-facing label and badge color, or each traffic-light state knowing how many seconds it lasts. The data travels with the value, so there's no separate lookup table to keep in sync.

Java is the clearest example: an enum is a full class, and each constant is a singleton instance that can hold fields and override methods. The prototype shows this — each status chip carries its own color and human label, defined right on the enum.

Constants: a single fixed value

Enums are for a set of related options. When you just have one fixed value that should never change — a tax rate, a max retry count, a config key — that's a constant: final in Java, const in TypeScript/C++, an UPPER_CASE module value in Python. Same spirit as an enum (name the value, don't repeat the magic literal), but for a lone value rather than a closed set.

Exhaustiveness: handling every case

The quiet superpower of enums is exhaustiveness checking. When you switch over an enum, the compiler (or linter) can verify you covered every member. Miss one — or add a new member later — and you get a warning at the exact spot that forgot it, instead of a silent fall-through at runtime.

function describe(s: OrderStatus): string {
  switch (s) {
    case OrderStatus.Pending:   return "Waiting for payment";
    case OrderStatus.Paid:      return "Preparing to ship";
    case OrderStatus.Shipped:   return "On its way";
    case OrderStatus.Delivered: return "Delivered";
    case OrderStatus.Cancelled: return "Cancelled";
    // forget a case and TypeScript flags the missing 'never' below
  }
}

When an enum is the right tool

Reach for an enum whenever a value comes from a small, fixed, known set of named options — order status, traffic-light color, day of the week, log level, card suit. If you catch yourself comparing against a handful of magic strings or integers, that's the signal: name the set, and let the compiler guarantee only those values exist. Use a plain constant instead when there's just one fixed value to name rather than a whole set.