Enums & Literal Types

📦 Enums & Literal Types

📝 String Enums

Basic String Enum

Copyenum Direction {
  Up = "UP",
  Down = "DOWN",
  Left = "LEFT",
  Right = "RIGHT"
}

function move(direction: Direction) {
  console.log(`Moving ${direction}`);
}

move(Direction.Up);      // ✅ "Moving UP"
move("UP");           // ❌ Error! String literal not allowed

Enum Without Explicit Values

If you don't specify values, TypeScript uses the member name:

Copyenum Status {
  Active,    // value is "Active"
  Inactive,  // value is "Inactive"
  Pending    // value is "Pending"
}

const status: Status = Status.Active;
console.log(status);  // "Active"

🔢 Numeric Enums

Copy// Numeric enums auto-increment
enum Level {
  Low = 0,
  Medium = 1,
  High = 2
}

// Or let TypeScript auto-increment
enum Priority {
  Low,       // 0
  Medium,    // 1
  High       // 2
}

// You can also start at any number
enum HttpStatus {
  OK = 200,
  NotFound = 404,
  ServerError = 500
}

Reverse Mapping (Numeric Enums Only)

With numeric enums, you can look up the name from the value:

Copyenum Status {
  Active = 0,
  Inactive = 1
}

// Forward mapping: Status.Active → 0
console.log(Status.Active);  // 0

// Reverse mapping: 0 → "Active"
console.log(Status[0]);     // "Active"

const code: number = 0;
console.log(Status[code]);  // "Active"

⚡ Const Enums

Copyconst enum Direction {
  Up = "UP",
  Down = "DOWN",
  Left = "LEFT",
  Right = "RIGHT"
}

function move(direction: Direction) {
  console.log(direction);
}

move(Direction.Up);

// Compiled JavaScript:
// function move(direction) { console.log(direction); }
// move("UP");

// Notice: Direction enum disappears! The value "UP" is inlined.

💎 Literal Types

String Literal Types

Copytype Size = "small" | "medium" | "large";

function setSize(size: Size) {
  console.log(`Size: ${size}`);
}

setSize("small");   // ✅
setSize("large");   // ✅
setSize("huge");    // ❌ Error! Not in the union

Number Literal Types

Copytype DiceRoll = 1 | 2 | 3 | 4 | 5 | 6;

function rollDice(roll: DiceRoll) {
  console.log(`You rolled: ${roll}`);
}

rollDice(3);   // ✅
rollDice(7);   // ❌ Error! 7 is not 1-6

Boolean Literal Types

Copytype OnOrOff = true | false;

// This is actually just boolean, but you can be more specific:
type Enabled = true;  // Only true is allowed

function enable(status: Enabled) {
  // status can only be true
}

enable(true);   // ✅
enable(false);  // ❌ Error!

🤔 Enums vs Literal Types

Both can represent restricted values. Which should you use?

🌍 Real-World Patterns

HTTP Status Codes

Copy// Using const enum
const enum HttpStatus {
  OK = 200,
  Created = 201,
  BadRequest = 400,
  Unauthorized = 401,
  NotFound = 404,
  ServerError = 500
}

function handleResponse(status: HttpStatus) {
  switch (status) {
    case HttpStatus.OK:
      console.log("Success");
      break;
    case HttpStatus.NotFound:
      console.log("Not found");
      break;
  }
}

Event Types with Literal Union

Copytype Event =
  | { type: "click"; x: number; y: number }
  | { type: "scroll"; delta: number }
  | { type: "keypress"; key: string };

function handleEvent(event: Event) {
  switch (event.type) {
    case "click":
      console.log(`Clicked at ${event.x}, ${event.y}`);
      break;
    case "scroll":
      console.log(`Scrolled ${event.delta}px`);
      break;
    case "keypress":
      console.log(`Pressed ${event.key}`);
      break;
  }
}

💻 Coding Challenges

📋 Best Practices

Copy// ✅ Better
type Status = "active" | "inactive" | "pending";

// ❌ Legacy
enum Status {
  Active = "active",
  Inactive = "inactive",
  Pending = "pending"
}

🎯 What's Next

We've mastered constants and restricted types. Chapter 10 covers Modules & Namespaces — how to organize code into reusable, maintainable modules and manage scope effectively.