Wat zijn enums en wanneer moet je ze gebruiken?

Question

Accepted Answer

Een **enum** definieert een set van benoemde constanten. TypeScript heeft numerieke en string enums.

```ts
enum Direction { Up, Down, Left, Right } // numeric: Up=0, Down=1, ...
Direction.Up;        // 0
Direction[0];        // "Up" — numeric enums have a reverse mapping

enum Status {        // string enum — more readable values
  Active = "ACTIVE",
  Inactive = "INACTIVE",
}
Status.Active;       // "ACTIVE"
```

## Een waarschuwing: enums genereren runtime-code

AFter most TypeScript types (die verdwijnen bij het compileren), emitteert een reguliere `enum` een JavaScript-object in je bundle. Daarom geven veel teams de voorkeur aan een **union van string literals** plus `as const`, wat zuiver type-level is:

```ts
// often preferred — zero runtime cost, easy to read in logs
const Status = { Active: "ACTIVE", Inactive: "INACTIVE" } as const;
type Status = typeof Status[keyof typeof Status]; // "ACTIVE" | "INACTIVE"

// or simply:
type Direction = "up" | "down" | "left" | "right";
```

## const enum

```ts
const enum E { A, B } // inlined at compile time — no runtime object, but has tooling caveats
```

## Waarom het belangrijk is

Enums geven betekenisvolle namen aan vaste sets (states, rollen, richtingen) en groeperen ze onder één namespace.

Maar omdat ze runtime-code genereren en eigenaardigheden hebben (numerieke enums worden los gecontroleerd), geeft modern TypeScript vaak de voorkeur aan **string-literal unions** voor eenvoudige gevallen — ze zijn lichter en serialiseren natuurlijk.

Gebruik enums wanneer je het namespacing of reverse mapping wilt.