PricingLoginStart free
TypeScript Academy · leksjon

Generiske begrensninger: snevre inn typeparametere

Bruk extends for å håndheve krav til strukturen i generiske typer.

Leksjon 2 av 413 trinn

Generiske begrensninger: snevre inn typeparametere er en gratis leksjon i TypeScript Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i TypeScript Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Velkommen

Avanserte generiske begrensninger lar deg snevre inn hvilke typer som kan brukes som typeargumenter, slik at du kan utføre typesikre operasjoner på komplekse strukturer.

Oppsummering av begrensninger

T extends U begrenser T til typer som er undertyper av U. Dermed får TypeScript informasjon om strukturen til T inne i funksjonen.
function len<T extends { length: number }>(val: T): number {
  return val.length;
}

Begrensning til bestemte metoder

Krev at T har en bestemt metode ved å begrense den til et grensesnitt som inneholder metoden.
interface Stringable { toString(): string; }
function stringify<T extends Stringable>(val: T): string {
  return val.toString();
}

Utledning fra en begrensning

Bruk keyof i begrensningen for å bygge sikre tilgangsfunksjoner.
function pluck<T, K extends keyof T>(items: T[], key: K): T[K][] {
  return items.map(item => item[key]);
}
const names = pluck(users, 'name'); // string[]

Høyereordens begrensninger (simulert)

TypeScript støtter ikke ekte høyereordens typer, men du kan simulere dem med betingede typer og begrensninger.

Begrensning til primitive typer

Begrens typeparametere til bestemte primitive typer for spesialiserte funksjoner.
type Primitive = string | number | boolean | bigint | symbol | null | undefined;
function isPrimitive<T extends Primitive>(val: T): true { return true; }

Rekursive begrensninger

Begrensninger kan referere til seg selv for rekursive mønstre.
interface Comparable<T> { compareTo(other: T): number; }
function sort<T extends Comparable<T>>(items: T[]): T[] {
  return [...items].sort((a, b) => a.compareTo(b));
}

Begrensning med standardverdi

En typeparameter kan ha både en begrensning og en standardverdi. Standardverdien må oppfylle begrensningen.
function process<T extends object = Record<string, unknown>>(data: T): void {
  console.log(Object.keys(data));
}

T extends Record<string, unknown>

Begrens til en record-type for å muliggjøre dynamisk tilgang til egenskaper.
function getValue<T extends Record<string, unknown>>(obj: T, key: string): unknown {
  return obj[key];
}

Utledning av begrensninger i returtyper

Når T er begrenset, bruker TypeScript begrensningen til å avgjøre hvilke operasjoner som er gyldige på returtypen.
function firstKey<T extends object>(obj: T): keyof T {
  return Object.keys(obj)[0] as keyof T;
}

NoInfer-verktøyet (TS 5.4)

TypeScript 5.4 introduserte NoInfer for å hindre at en typeparameter utledes fra en bestemt argumentposisjon.
function createState<T>(initial: T, fallback: NoInfer<T>): T {
  return initial ?? fallback;
}

Kunnskapssjekk

Hvilken informasjon gir `T extends { length: number }` om T inne i en generisk funksjon?
Besvar den i den interaktive leksjonen

Oppsummering

Avanserte begrensninger snevrer inn generiske typer til bestemte strukturer, metoder eller primitive unioner. Kombiner dem med keyof, rekursive mønstre og standardverdier for å bygge kraftige typesikre verktøy.
Gratis å komme i gang

Lær deg TypeScript med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs
101
Leksjoner
352
Start læringen gratisSe hele kurset

Ofte stilte spørsmål

Er leksjonen «Generiske begrensninger: snevre inn typeparametere» gratis?

Ja – hele teksten i «Generiske begrensninger: snevre inn typeparametere» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av TypeScript Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i TypeScript Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Generiske begrensninger: snevre inn typeparametere»?

Bruk extends for å håndheve krav til strukturen i generiske typer. Du øver på TypeScript Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med TypeScript Academy?

Ingen tidligere erfaring er nødvendig. TypeScript Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «Generiske begrensninger: snevre inn typeparametere»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne TypeScript Academy-leksjonen?

Ja. Alle TypeScript Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

  1. keyof og indekserte tilgangstyper
  2. Generiske begrensninger: snevre inn typeparametere
  3. Betingede typer: T extends U ? X : Y
  4. Distribuerende betingede typer
← Tilbake til TypeScript Academy