TypeScript Academy · leksjon

Betingelser på typenivå

Forgren deg basert på typer med betingede typeuttrykk.

Leksjon 2 av 413 trinn

Betingelser på typenivå 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.

if på typenivå

Typespråket får forgreninger med betingede typer. Syntaksen T extends U ? X : Y leses slik: Hvis T kan tilordnes til U, er resultatet X; ellers er det Y.

Dette tilsvarer en if / else-uttrykk på typenivå.

type IsString<T> = T extends string ? "yes" : "no";

type A = IsString<string>; // "yes"
type B = IsString<number>; // "no"

extends betyr tilordningsbar

Testen gjelder ikke likhet. T extends U er sann når en verdi av typen T kan brukes der det forventes en U. Literaltyper kan tilordnes til grunntypen sin.

type T1 = "hello" extends string ? true : false; // true
type T2 = string extends "hello" ? true : false; // false
type T3 = 42 extends number ? true : false;       // true

Valg av resultattype

Betingelser lar én generisk type returnere ulike former avhengig av inndataene. Her omslutter Wrap arrayer annerledes enn skalarer.

type Wrap<T> = T extends unknown[]
  ? { list: T }
  : { value: T };

type A = Wrap<number>;   // { value: number }
type B = Wrap<string[]>; // { list: string[] }

Filtrering til never

Et vanlig triks er å returnere never i én gren. never betyr «ingen verdi», og er nyttig for å fjerne medlemmer fra unioner senere.

type OnlyStrings<T> = T extends string ? T : never;

type A = OnlyStrings<string>; // string
type B = OnlyStrings<number>; // never

Typeutledning med infer

Den virkelige kraften vises med nøkkelordet infer. Inne i en betingelse introduserer infer en ny typevariabel som fanger opp en del av typen som ble matchet.

Her fanger vi opp elementtypen i en array.

type ElementType<T> = T extends (infer U)[] ? U : never;

type A = ElementType<number[]>; // number
type B = ElementType<string[]>; // string

Utledning av funksjonsresultater

infer kan plasseres hvor som helst i mønsteret. For å trekke ut returtypen til en funksjon utleder du delen etter pilen. Det er slik det innebygde verktøyet ReturnType fungerer.

type MyReturn<T> = T extends (...args: any[]) => infer R ? R : never;

type A = MyReturn<() => number>;      // number
type B = MyReturn<(x: string) => boolean>; // boolean

Utledning av flere deler

Én enkelt betingelse kan introdusere flere infer-variabler samtidig. Her henter vi ut både det første elementet og resten av en tuple.

type FirstRest<T> = T extends [infer H, ...infer R]
  ? { head: H; rest: R }
  : never;

type A = FirstRest<[1, 2, 3]>;
// { head: 1; rest: [2, 3] }

Nestede betingelser

Betingelser kan nøstes på samme måte som lenkede else if-setninger. Else-grenen i én betingelse kan selv være en annen betingelse, slik at det dannes en beslutningsstige.

type Describe<T> =
  T extends string ? "text" :
  T extends number ? "num" :
  T extends boolean ? "flag" :
  "other";

type A = Describe<number>; // "num"
type B = Describe<null>;   // "other"

Betingelser som vakter

Bruk en betingelse til å kontrollere strukturen før du trekker ut noe fra den. Hvis inndataene ikke passer, kan du falle tilbake til never, slik at feil bruk blir synlig.

type GetName<T> = T extends { name: infer N } ? N : never;

type A = GetName<{ name: string }>; // string
type B = GetName<{ age: number }>;  // never

Kombinering av betingelser

Du kan kreve flere betingelser ved å nøste dem. Her må en type både være et objekt og ha en id for å bestå.

type RequireId<T> =
  T extends object
    ? T extends { id: unknown } ? T : never
    : never;

type A = RequireId<{ id: 1; x: 2 }>; // { id: 1; x: 2 }
type B = RequireId<{ x: 2 }>;        // never

Betingede typer finnes overalt

De fleste innebygde verktøytypene er i bunn og grunn betingelser: NonNullable, Extract, Exclude, Parameters og ReturnType. Når du forstår extends ? :, får du tilgang til alle.

type MyNonNullable<T> = T extends null | undefined ? never : T;

type A = MyNonNullable<string | null>; // string

Kort sjekk

Test forståelsen din av betingede typer og infer.

Besvar den i den interaktive leksjonen

Oppsummering

Betingede typer gir typespråket if/else og mønstertilpasning.

T extends U ? X : Y forgrener basert på tilordningsbarhet.
infer fanger opp matchede deler i nye variabler.
Betingelser kan nøstes for å danne beslutningsstiger.
Ved å returnere never filtreres medlemmer bort.

Neste: å føre en betingelse tilbake inn i seg selv for rekursjon.

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 «Betingelser på typenivå» gratis?

Ja – hele teksten i «Betingelser på typenivå» 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 «Betingelser på typenivå»?

Forgren deg basert på typer med betingede typeuttrykk. 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 «Betingelser på typenivå»?

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

← Tilbake til TypeScript Academy