Union- en intersectietypen

Welkom bij de volgende les! In deze les leer je hoe je unietypen gebruikt om meerdere mogelijke typen voor een variabele toe te staan en doorsnedetypen om meerdere typen tot één type te combineren. Dit zijn krachtige hulpmiddelen om flexibele en robuuste code te maken. Laten we beginnen!

Met unietypen kan een variabele meer dan één type bevatten. Je kunt het symbool | gebruiken om een unietype te definiëren.

Voorbeeld: Een variabele die een tekenreeks of een getal kan zijn:

Opdracht: Declareer een variabele met een unietype en wijs er verschillende waarden aan toe.

let value: string | number;
value = "Hello";
console.log(value); // Output: "Hello"

value = 42;
console.log(value); // Output: 42

Je kunt unietypen gebruiken in functieparameters om meerdere invoertypen toe te staan. Voorbeeld:

Opdracht: Schrijf een functie die een parameter van een unietype accepteert en deze naar de console schrijft.

function printValue(value: string | number): void {
  console.log(`The value is ${value}`);
}

printValue("Hello"); // Output: The value is Hello
printValue(100); // Output: The value is 100

Met doorsnedetypen combineer je meerdere typen tot één type. Je kunt het symbool & gebruiken om een doorsnedetype te definiëren.

Voorbeeld: Twee objecttypen combineren:

Opdracht: Maak een doorsnedetype om twee objecten te combineren en gebruik het.

type Person = { name: string };
type Employee = { employeeId: number };

type Staff = Person & Employee;

let staffMember: Staff = {
  name: "Alice",
  employeeId: 123,
};

console.log(staffMember);

TypeScript weet niet welk type je in een unietype gebruikt. Je kunt typebewaking gebruiken om het type te verfijnen. Voorbeeld:

Opdracht: Gebruik typebewaking om verschillende typen in een unietype af te handelen.

function display(value: string | number): void {
  if (typeof value === "string") {
    console.log(`String value: ${value.toUpperCase()}`);
  } else {
    console.log(`Number value: ${value * 2}`);
  }
}

display("Hello"); // Output: String value: HELLO
display(5); // Output: Number value: 10

Doorsnedetypen zijn handig bij het werken met objecten die eigenschappen delen. Voorbeeld:

Opdracht: Maak een doorsnedetype voor beheerders- en gebruikersrollen.

type Admin = { adminLevel: string };
type User = { username: string };

type AdminUser = Admin & User;

let admin: AdminUser = {
  adminLevel: "super",
  username: "admin123",
};

console.log(`Admin ${admin.username} has level ${admin.adminLevel}`);

Hier volgen enkele veelgemaakte fouten:

• Een unietype gebruiken zonder alle mogelijke gevallen af te handelen, bijvoorbeeld door een typebewaking te vergeten.
• Typen onnodig ingewikkeld maken met overbodige doorsnedetypen.
• Onverenigbare waarden toewijzen aan een unie- of doorsnedetype.

Tip: Test je code altijd om te controleren of de typen werken zoals verwacht!

Gebruik unietypen wanneer:

• Een variabele één van meerdere mogelijke typen kan hebben.
• Je flexibiliteit in functieparameters nodig hebt.

Gebruik doorsnedetypen wanneer:

• Je meerdere objecten of typen tot één type combineert.
• Je complexere typen voor specifieke toepassingen maakt.

Gefeliciteerd! Je hebt geleerd hoe je unie- en doorsnedetypen gebruikt om complexe situaties in TypeScript af te handelen. Met deze hulpmiddelen wordt je code flexibeler en duidelijker. In de volgende les bekijken we enumeraties en hoe die helpen bij het beheren van constante waarden. Laten we blijven programmeren!