Avancerade TypeScript-typer förklaras med exempel

TypeScript erbjuder flera avancerade typer som går utöver grundläggande typer, vilket möjliggör mer flexibla och kraftfulla typsystem. Dessa avancerade typer hjälper till att skapa robusta applikationer genom att tillhandahålla ytterligare sätt att definiera och upprätthålla typbegränsningar. Den här artikeln utforskar några av dessa avancerade typer med exempel.

Fackliga typer

Unionstyper tillåter en variabel att vara en av flera typer. Detta kan vara användbart när ett värde kan vara av flera typer men bör hanteras på lämpligt sätt baserat på dess faktiska typ.

// 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 det här exemplet accepterar funktionen "formatValue" antingen en sträng eller ett tal och formaterar värdet därefter.

Typer av korsningar

Korsningstyper kombinerar flera typer till en. Ett objekt av en skärningstyp kommer att ha alla egenskaper för de kombinerade typerna. Detta är användbart för att komponera flera typer tillsammans.

// 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);

Här är "Anställd"-typen en skärningspunkt mellan "Person" och "Kontakt", vilket betyder att den innehåller egenskaper från båda gränssnitten.

Bokstavliga typer

Bokstavstyper anger exakta värden som en variabel kan hålla. Detta kan vara särskilt användbart för att säkerställa att endast vissa specifika värden är tillåtna.

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

`Riktning`-typen här är begränsad till fyra specifika strängvärden, vilket säkerställer att endast dessa riktningar kan användas i `flytta`-funktionen.

Tuppeltyper

Tuppeltyper representerar en array med ett fast antal element där varje element kan ha en annan typ. Tuples är användbara för att representera samlingar av heterogena föremål i fast storlek.

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

Användartuppeln definieras med en sträng följt av ett nummer, och denna struktur måste bibehållas.

Villkorliga typer

Villkorstyper gör att typer kan bestämmas baserat på villkor. De ger ett sätt att välja en eller annan typ baserat på ett tillstånd.

// Conditional type example

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

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

I det här exemplet kontrollerar typen "IsString" om en typ "T" är en sträng. Den returnerar "Ja" om det är det och "Nej" annars.

Kartlagda typer

Mappade typer gör det möjligt att skapa nya typer genom att transformera egenskaper hos en befintlig typ. Detta är användbart för att modifiera eller utöka befintliga 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 transformerar 'Person'-typen genom att göra alla dess egenskaper skrivskyddade.

Slutsats

TypeScripts avancerade typer ger kraftfulla verktyg för att definiera och hantera komplexa typkrav. Genom att använda unions-, korsnings-, bokstavs-, tupel-, villkors- och mappade typer kan utvecklare skapa mer robusta och underhållbara applikationer. Att förstå och tillämpa dessa typer effektivt kan avsevärt förbättra typsäkerheten och flexibiliteten för TypeScript-kod.