Unionstyper och intersectionstyper

Välkommen till nästa lektion! I den här lektionen får du lära dig hur du använder uniontyper för att tillåta flera möjliga typer för en variabel och intersektionstyper för att kombinera flera typer till en enda. Det här är kraftfulla verktyg för att skapa flexibel och robust kod. Nu sätter vi igång!

Uniontyper gör att en variabel kan innehålla mer än en typ. Du kan använda symbolen | för att definiera en uniontyp.

Exempel: En variabel som kan vara antingen en sträng eller ett tal:

Uppgift: Deklarera en variabel med en uniontyp och tilldela den olika värden.

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

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

Du kan använda uniontyper i funktionsparametrar för att tillåta flera indatatyper. Exempel:

Uppgift: Skriv en funktion som tar emot en parameter av en uniontyp och loggar den i konsolen.

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

Intersektionstyper kombinerar flera typer till en enda. Du kan använda symbolen & för att definiera en intersektionstyp.

Exempel: Kombinera två objekttyper:

Uppgift: Skapa en intersektionstyp för att kombinera två objekt och använd den.

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

type Staff = Person & Employee;

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

console.log(staffMember);

TypeScript vet inte vilken typ du använder i en uniontyp. Du kan använda typvakter för att begränsa typen. Exempel:

Uppgift: Använd typvakter för att hantera olika typer i en uniontyp.

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

Intersektionstyper är användbara när du arbetar med objekt som delar egenskaper. Exempel:

Uppgift: Skapa en intersektionstyp för administratörs- och användarroller.

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}`);

Här är några vanliga misstag:

• Att använda en uniontyp utan att hantera alla möjliga fall (till exempel att glömma en typvakt).
• Att göra typerna onödigt komplicerade med överflödiga intersektioner.
• Att tilldela inkompatibla värden till en uniontyp eller intersektionstyp.

Tips: Testa alltid koden för att säkerställa att typerna fungerar som förväntat!

Använd uniontyper när:

• En variabel kan ha en av flera möjliga typer.
• Du behöver flexibilitet i funktionsparametrar.

Använd intersektionstyper när:

• Du kombinerar flera objekt eller typer till en enda.
• Du skapar mer komplexa typer för specifika användningsområden.

Grattis! Du har lärt dig hur du använder uniontyper och intersektionstyper för att hantera komplexa situationer i TypeScript. De här verktygen gör koden mer flexibel och uttrycksfull. I nästa lektion ska vi utforska enum och hur de hjälper dig att hantera konstanta värden. Fortsätt koda!