📘 Day 3 – TypeScript: Union Types, Type Aliases & Enums

🚀 TypeScript Learning Journey – Day 3

Topic: Union Types, Type Aliases & Enums

Welcome back to the series! 👋
On Day 1, we explored variables, arrays, and functions.
On Day 2, we leveled up with interfaces, optional fields, and readonly properties.

Now on Day 3, we’re adding three new tools to our TypeScript toolbox:

• Union Types

• Type Aliases

• Enums

These features may sound fancy, but they make your code much easier to manage in real-world projects. Let’s break them down with simple examples.

🔗 Union Types – “Either this or that”

A union type means a variable can accept more than one type.
Think of it like a train station where different trains can stop — but only the ones you allow.

let value: string | number;

value = "Hello"; // ✅ works fine
value = 42;      // ✅ also works
// value = true; // ❌ not allowed

Functions also benefit from unions:

function printId(id: string | number) {
  console.log("ID:", id);
}

printId(101);      // ID: 101
printId("xyz123"); // ID: xyz123

👉 Why is it useful?
When your program accepts more than one input type (e.g., ID as a number or string), you can enforce it clearly with unions.

🏷️ Type Aliases – Giving Names to Types

If you keep repeating the same type, it becomes noisy.
A type alias is like giving a nickname to a type, so your code looks clean.

Example with a union:

type ID = string | number;

let userId: ID;
userId = 123;   // ✅ OK
userId = "abc"; // ✅ OK

For objects:

type Car = {
  brand: string;
  year: number;
};

const car1: Car = { brand: "Tata", year: 2025 };

👉 When to use?

• Use interfaces when you’re describing the shape of an object.

• Use type aliases for unions, intersections, or reusable type shortcuts.

🎯 Enums – Fixed Sets of Choices

Enums are great when you have a limited list of options.
Instead of random strings everywhere, you define them once and reuse them safely.

Example: Fuel Types

enum FuelType {
  Petrol,
  Diesel,
  Electric
}

const myCar = {
  brand: "Tesla",
  fuel: FuelType.Electric
};

console.log(myCar);
// { brand: 'Tesla', fuel: 2 }

By default, enums start at 0. But numbers can be confusing, so let’s switch to string enums for clarity:

enum FuelType {
  Petrol = "PETROL",
  Diesel = "DIESEL",
  Electric = "ELECTRIC"
}

const car2 = { brand: "Tata", fuel: FuelType.Diesel };

console.log(car2);
// { brand: 'Tata', fuel: 'DIESEL' }

👉 Why useful?

• Prevents typos ("Petrol" vs "petroL")

• Keeps your code consistent

• Makes intent clear

📝 Exercises

1. Union Type

type Status = "success" | "error";

function printStatus(status: Status) {
  console.log("Status:", status);
}

printStatus("success"); // Status: success
printStatus("error");   // Status: error

2. Type Alias

type Point = { x: number; y: number };

const point1: Point = { x: 10, y: 20 };

console.log(point1);
// { x: 10, y: 20 }

3. Enum

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

const move = Direction.Left;

console.log(move);
// LEFT

✅ Recap

• Union types allow multiple possible types.

• Type aliases simplify code by giving names to types.

• Enums handle fixed sets of choices safely.

These three concepts make your code less prone to errors and more readable.

🔮 Coming Up Next (Day 4)

On Day 4, we’ll dive into Generics — a powerful way to write flexible and reusable code without losing type safety.

Stay tuned — this is where TypeScript starts to feel really powerful. 💪

🎯 Key Takeaways

• Union types let variables hold a small set of possible types.

• Type aliases make code cleaner by avoiding repetition.

• Enums are the best choice when you have a fixed set of options.

With these, your TypeScript toolbox is growing — and you’ll see them everywhere in real-world projects.

Powered by wisp