TypeScript avanserte typer forklart med eksempler

TypeScript tilbyr flere avanserte typer som går utover grunnleggende typer, noe som gir mulighet for mer fleksible og kraftige typesystemer. Disse avanserte typene hjelper til med å lage robuste applikasjoner ved å tilby flere måter å definere og håndheve typebegrensninger. Denne artikkelen utforsker noen av disse avanserte typene med eksempler.

Unionstyper

Unionstyper lar en variabel være en av flere typer. Dette kan være nyttig når en verdi kan være av flere typer, men bør håndteres riktig basert på den faktiske typen.

// 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 eksemplet godtar "formatValue"-funksjonen enten en streng eller et tall og formaterer verdien deretter.

Krysstyper

Krysstyper kombinerer flere typer til én. Et objekt av en skjæringstype vil ha alle egenskapene til de kombinerte typene. Dette er nyttig for å 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 `Ansatt`-typen et skjæringspunkt mellom `Person` og `Kontakt`, noe som betyr at den inneholder egenskaper fra begge grensesnittene.

Bokstavelige typer

Bokstavtyper spesifiserer nøyaktige verdier en variabel kan inneholde. Dette kan være spesielt nyttig for å sikre at bare visse spesifikke verdier er tillatt.

// 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 begrenset til fire spesifikke strengverdier, noe som sikrer at bare disse retningene kan brukes i 'flytte'-funksjonen.

Tuple typer

Tuppeltyper representerer en matrise med et fast antall elementer der hvert element kan ha en annen type. Tuples er nyttige for å representere samlinger av heterogene gjenstander i fast størrelse.

// 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'.

`Bruker`-tuppelen er definert med en streng etterfulgt av et tall, og denne strukturen må opprettholdes.

Betingede typer

Betingede typer gjør det mulig å bestemme typer basert på forhold. De gir en måte å velge en eller annen type basert på en tilstand.

// Conditional type example

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

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

I dette eksemplet sjekker "IsString"-typen om en type "T" er en streng. Den returnerer "Ja" hvis det er det og "Nei" ellers.

Kartlagte typer

Kartlagte typer gjør det mulig å lage nye typer ved å transformere egenskaper for en eksisterende type. Dette er nyttig for å endre eller utvide 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 å gjøre alle egenskapene skrivebeskyttede.

Konklusjon

TypeScripts avanserte typer gir kraftige verktøy for å definere og administrere komplekse typekrav. Ved å bruke unions-, skjærings-, literal-, tuple-, betingede og kartlagte typer, kan utviklere lage mer robuste og vedlikeholdbare applikasjoner. Å forstå og bruke disse typene effektivt kan forbedre typesikkerheten og fleksibiliteten til TypeScript-kode betydelig.