TypeScript avancerede typer forklaret med eksempler

TypeScript tilbyder flere avancerede typer, der går ud over de grundlæggende typer, hvilket giver mulighed for mere fleksible og kraftfulde typesystemer. Disse avancerede typer hjælper med at skabe robuste applikationer ved at give yderligere måder at definere og håndhæve typebegrænsninger. Denne artikel udforsker nogle af disse avancerede typer med eksempler.

Unionstyper

Unionstyper tillader en variabel at være en af ​​flere typer. Dette kan være nyttigt, når en værdi kan være af flere typer, men skal håndteres korrekt baseret på dens faktiske type.

// Union type example

function formatValue(value: string | number): string {
  if (typeof value === 'string') {
    return `String: ${value}`;
  } else {
    return `Number: ${value.toFixed(2)}`;
  }
}

console.log(formatValue("Hello"));
console.log(formatValue(123.456));

I dette eksempel accepterer funktionen "formatValue" enten en streng eller et tal og formaterer værdien i overensstemmelse hermed.

Typer af kryds

Krydstyper kombinerer flere typer til én. Et objekt af en skæringstype vil have alle de kombinerede typers egenskaber. Dette er nyttigt til at komponere flere typer sammen.

// Intersection type example

interface Person {
  name: string;
  age: number;
}

interface Contact {
  email: string;
  phone: string;
}

type Employee = Person & Contact;

const employee: Employee = {
  name: "John Doe",
  age: 30,
  email: "john.doe@example.com",
  phone: "123-456-7890"
};

console.log(employee);

Her er `Medarbejder`-typen et skæringspunkt mellem `Person` og `Kontakt`, hvilket betyder, at den indeholder egenskaber fra begge grænseflader.

Bogstavelige typer

Lettere typer angiver nøjagtige værdier, som en variabel kan indeholde. Dette kan være særligt nyttigt for at sikre, at kun bestemte specifikke værdier er tilladt.

// Literal type example

type Direction = "up" | "down" | "left" | "right";

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

move("up");    // Valid
move("down");  // Valid
// move("side"); // Error: Argument of type '"side"' is not assignable to parameter of type 'Direction'.

'Retning'-typen her er begrænset til fire specifikke strengværdier, hvilket sikrer, at kun disse retninger kan bruges i 'move'-funktionen.

Tuple typer

Tuple typer repræsenterer et array med et fast antal elementer, hvor hvert element kan have en anden type. Tuples er nyttige til at repræsentere samlinger af fast størrelse af heterogene genstande.

// Tuple type example

let user: [string, number] = ["Alice", 30];

console.log(user[0]); // "Alice"
console.log(user[1]); // 30

// user = [30, "Alice"]; // Error: Type 'number' is not assignable to type 'string'.

`Bruger`-tuplen er defineret med en streng efterfulgt af et tal, og denne struktur skal vedligeholdes.

Betingede typer

Betingede typer gør det muligt at bestemme typer baseret på betingelser. De giver mulighed for at vælge en eller anden type baseret på en betingelse.

// Conditional type example

type IsString = T extends string ? "Yes" : "No";

type Test1 = IsString;  // "Yes"
type Test2 = IsString;  // "No"

I dette eksempel kontrollerer 'IsString'-typen, om en type 'T' er en streng. Det returnerer `"Ja"` hvis det er og `"Nej"` ellers.

Kortlagte typer

Tilknyttede typer giver mulighed for at oprette nye typer ved at transformere egenskaber for en eksisterende type. Dette er nyttigt til at ændre eller udvide eksisterende typer.

// Mapped type example

type ReadonlyPerson = {
  readonly [K in keyof Person]: Person[K];
};

const readonlyPerson: ReadonlyPerson = {
  name: "Alice",
  age: 30
};

// readonlyPerson.age = 31; // Error: Cannot assign to 'age' because it is a read-only property.

'ReadonlyPerson'-typen transformerer 'Person'-typen ved at gøre alle dens egenskaber skrivebeskyttet.

Konklusion

TypeScripts avancerede typer giver kraftfulde værktøjer til at definere og administrere komplekse typekrav. Ved at bruge unions-, skærings-, literal-, tuple-, betingede og kortlagte typer kan udviklere skabe mere robuste og vedligeholdelige applikationer. Forståelse og anvendelse af disse typer effektivt kan forbedre typesikkerheden og fleksibiliteten af ​​TypeScript-kode markant.