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.