TypeScript Union og Intersection Types

TypeScript leverer kraftfulde typesystemfunktioner, der hjælper dig med at skrive sikrere og mere forudsigelig kode. Blandt disse funktioner er unions- og skæringstyper, som giver fleksibilitet til at definere og styre komplekse typer. Denne artikel introducerer disse begreber og giver eksempler til at illustrere deres brug.

Hvad er foreningstyper?

Unionstyper tillader en variabel at indeholde værdier af forskellige typer. Dette er nyttigt, når du skal repræsentere en værdi, der kan være en af ​​flere typer. Unionstyper er angivet ved hjælp af | (rør) symbolet.

Definition af foreningstyper

For at definere en foreningstype angiver du flere typer adskilt af |-symbolet:

let value: string | number;

value = "Hello, TypeScript"; // Valid
value = 42; // Valid
value = true; // Error: Type 'boolean' is not assignable to type 'string | number'

I dette eksempel kan variablen værdi enten være en streng eller et tal, men ikke en boolean.

Brug af foreningstyper i funktioner

Unionstyper er særligt nyttige i funktioner, hvor parametre eller returtyper kan være flere typer:

function formatValue(value: string | number): string {
  if (typeof value === "string") {
    return value.toUpperCase();
  } else {
    return value.toFixed(2);
  }
}

console.log(formatValue("hello")); // Output: HELLO
console.log(formatValue(123.456)); // Output: 123.46

Funktionen formatValue tager en parameter, der kan være enten en streng eller et tal og formaterer den i overensstemmelse hermed.

Hvad er krydsningstyper?

Krydstyper giver dig mulighed for at kombinere flere typer til én. Det betyder, at en værdi af krydstypen vil tilfredsstille alle typer i krydset. Skæringstyper er angivet ved hjælp af & (amperand) symbolet.

Definition af skæringstyper

For at definere en skæringstype angiver du flere typer adskilt af &-symbolet:

interface Person {
  name: string;
}

interface Employee {
  employeeId: number;
}

type EmployeePerson = Person & Employee;

const john: EmployeePerson = {
  name: "John Doe",
  employeeId: 1234
};

console.log(john.name); // Output: John Doe
console.log(john.employeeId); // Output: 1234

I dette eksempel kombinerer EmployeePerson-typen Person- og Employee-grænsefladerne, hvilket resulterer i en type, der både har name og werknemerId egenskaber.

Brug af skæringstyper i funktioner

Skæringstyper kan også bruges i funktioner, der kræver flere typeegenskaber:

function printEmployeeDetails(employee: Person & Employee): void {
  console.log(`Name: ${employee.name}`);
  console.log(`Employee ID: ${employee.employeeId}`);
}

const jane: EmployeePerson = {
  name: "Jane Smith",
  employeeId: 5678
};

printEmployeeDetails(jane);
// Output:
// Name: Jane Smith
// Employee ID: 5678

Funktionen printEmployeeDetails kræver et argument, der opfylder både Person og Employee typerne.

Kombination af unions- og vejkrydstyper

Du kan kombinere forenings- og skæringstyper for at skabe komplekse typedefinitioner:

type Shape = Circle | Rectangle;

interface Circle {
  kind: "circle";
  radius: number;
}

interface Rectangle {
  kind: "rectangle";
  width: number;
  height: number;
}

function getArea(shape: Shape): number {
  if (shape.kind === "circle") {
    return Math.PI * shape.radius * shape.radius;
  } else {
    return shape.width * shape.height;
  }
}

const myCircle: Circle = { kind: "circle", radius: 10 };
const myRectangle: Rectangle = { kind: "rectangle", width: 20, height: 30 };

console.log(getArea(myCircle)); // Output: 314.159...
console.log(getArea(myRectangle)); // Output: 600

I dette eksempel er Shape-typen en forening af Cirkel og Rektangel, og getArea-funktionen håndterer begge typer i overensstemmelse hermed.

Konklusion

Unions- og skæringstyper i TypeScript giver effektive måder at administrere og kombinere typer på, hvilket giver fleksibilitet og præcision i typedefinitioner. Unionstyper tillader en variabel at være en af ​​flere typer, mens skæringstyper kombinerer flere typer til én. Ved at bruge disse funktioner kan du skabe mere robuste og typesikre applikationer.

Øv dig i at bruge unions- og skæringstyper for at blive fortrolig med deres muligheder og forbedre dine TypeScript-kodningsfærdigheder.