TypeScript Academy · leksjon

Unngå kostbare typeoperasjoner

Finn og rett opp dypt rekursive eller distribuerende typer.

Leksjon 2 av 413 trinn

Unngå kostbare typeoperasjoner 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.

Hva gjør en typeoperasjon kostbar?

Dypt rekursive typer, store union-distribusjoner og komplekse infer-kjeder tvinger TypeScript til å instansiere mange typevarianter, noe som fører til eksponentiell treghet.

// Expensive: distributes over every member of a large union
type FilterStrings<T> = T extends string ? T : never;
type Result = FilterStrings<string | number | boolean | null | undefined | ...>;

Unngå for store unioner

Unioner med hundrevis av medlemmer, for eksempel fra mange strengliteraler, kan gjøre typesjekkingen svært treg. Vurder å snevre inn domenet eller bruke string med validering.

// Expensive
type HugeUnion = "a" | "b" | "c" | /* 200 more ... */ "z";
// Better: string with a runtime check
function isValid(s: string): s is ValidString { return VALID_SET.has(s); }

Foretrekk grensesnitt fremfor komplekse typealiaser

TypeScript mellomlagrer grensesnitt mer aggressivt enn komplekse snitt av typealiaser. Foretrekk interface for objektformer som refereres til mange ganger.

// Slow: recomputed union intersection each time
type BigObject = TypeA & TypeB & TypeC & TypeD;
// Fast: interface (cached)
interface BigObject extends TypeA, TypeB, TypeC, TypeD {}

Begrens rekursjonsdybden

Rekursive betingede typer er kraftige, men kan nå TypeScripts dybdegrense, vanligvis 100 nivåer. Legg til en dybdesteller for å avslutte tidlig.

type Flatten<T, Depth extends number[] = []> =
  Depth["length"] extends 10 ? T
  : T extends (infer U)[] ? Flatten<U, [...Depth, 0]>
  : T;

Mellomlagre mellomtyper

Gi komplekse mellomtyper navn, slik at TypeScript kan mellomlagre og gjenbruke dem i stedet for å beregne dem på nytt ved hver referanse.

// Before: recomputed at each use
type MyResult<T> = T extends SomeComplex<infer U> ? Transform<U> : never;

// After: split into named intermediates
type ExtractU<T> = T extends SomeComplex<infer U> ? U : never;
type MyResult<T> = Transform<ExtractU<T>>;

Unngå dype mappede typer på store objekter

Hvis du bruker DeepReadonly på en svært stor objekttype, må TypeScript gå rekursivt gjennom hver egenskap, noe som er kostbart.

// Expensive on 50-property nested objects
type Safe = DeepReadonly<HugeConfig>;
// Better: annotate at creation time with const assertions

Bruk lat generisk evaluering

Hvis du pakker en kostbar type inn i en thunk, altså en funksjonstype som returnerer den, utsettes evalueringen til typen faktisk trengs.

// Lazy evaluation via wrapper
type Lazy<T> = () => T;
type ExpensiveLazy = Lazy<DeepReadonly<HugeConfig>>;

Foretrekk eksplisitte returtyper

Ved å angi funksjonenes returtyper eksplisitt slipper TypeScript å utlede dem på nytt ved hvert kallested, noe som gjør typesjekkingen raskere.

// Let TypeScript infer (may be slow for complex functions)
function process(data: Input) { return transform(data); }

// Faster: explicit annotation
function process(data: Input): Output { return transform(data); }

isolatedDeclarations for parallell typesjekking

isolatedDeclarations i TypeScript 5.5 og nyere krever eksplisitte returtyper og gjør parallell typesjekking av uavhengige filer mulig uten full typeinferens.

// tsconfig.json
{
  "compilerOptions": {
    "isolatedDeclarations": true
  }
}

Prosjektreferanser for isolering

Prosjektreferanser hindrer TypeScript i å typesjekke pakker som ikke er endret, noe som gir størst gevinst i store monorepoer.

# With project references:
# tsc --build only recompiles packages whose sources changed
# Unchanged packages: declaration files used directly

Oppsummering: Unngå kostbare typer

Hold TypeScript raskt ved å unngå enorme unioner, mellomlagre mellomtyper, foretrekke grensesnitt fremfor komplekse aliaser, begrense rekursjonsdybden, bruke eksplisitte returtyper og isolere pakker med prosjektreferanser.

Hurtigsjekk

Hvilken tilnærming hjelper TypeScript med å mellomlagre en objektform mer aggressivt?

Besvar den i den interaktive leksjonen

Dette har du lært

Kostbare TypeScript-typeoperasjoner omfatter store unioner, dyp rekursjon og gjentatt kompleks inferens. Optimaliser ved å mellomlagre mellomtyper, foretrekke grensesnitt, begrense størrelsen på unioner og bruke prosjektreferanser i monorepoer.

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 gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Unngå kostbare typeoperasjoner» gratis?

Ja – hele teksten i «Unngå kostbare typeoperasjoner» 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 «Unngå kostbare typeoperasjoner»?

Finn og rett opp dypt rekursive eller distribuerende 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 «Unngå kostbare typeoperasjoner»?

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

Profilere treg TypeScript-kompilering
Unngå kostbare typeoperasjoner
skipLibCheck og isolerte deklarasjoner
Typesjekking i CI: strategier og verktøy

← Tilbake til TypeScript Academy