TypeScript Academy · Lektion

Distributiva villkorstyper

Styr hur villkor distribueras över unioner.

Lektion 4 av 413 steg

Distributiva villkorstyper är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för TypeScript Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Ett överraskande beteende

Villkorstyper har en särskild regel: när den kontrollerade typen är en naken typparameter och ni skickar in en union, distribueras villkoret separat över varje medlem, varefter resultaten förenas till en union.

Detta är grunden för Exclude, Extract och många andra verktyg.

type ToArray<T> = T extends unknown ? T[] : never;

type A = ToArray<string | number>;
// string[] | number[]  (NOT (string | number)[])

Vad ”naken” betyder

”Naken” betyder att typparametern står för sig själv till vänster om extends, utan att vara inlindad i en annan typ. Distribution sker bara för nakna parametrar.

type Naked<T> = T extends string ? "y" : "n";
// T is naked -> distributes over unions

Distribution steg för steg

För ToArray<string | number> utvärderar kompilatorn varje medlem:

ToArray<string> = string[]
ToArray<number> = number[]

Därefter förenas de: string[] | number[].

type R = ToArray<boolean>;
// boolean is true | false, so:
// true[] | false[]

Filtrera en union

Distribution gör filtrering enkelt. Mappa oönskade medlemmar till never; never försvinner ur en union, så bara de medlemmar som ska behållas återstår.

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

type A = Strings<string | number | boolean>; // string

never försvinner i unioner

Ett viktigt faktum är att X | never förenklas till X. När en distribuerad gren därför ger never tas den medlemmen i praktiken bort från den slutliga unionen.

type A = string | never;        // string
type B = "a" | never | "b";     // "a" | "b"

Inaktivera distribution

Ibland vill ni inte ha distribution, till exempel när en hel union ska jämföras som en enhet. Omslut båda sidorna i en tupel med ett element: [T] extends [U]. Nu är T inte längre naken, så distributionen är avstängd.

type IsNever<T> = [T] extends [never] ? true : false;

type A = IsNever<never>;  // true
type B = IsNever<string>; // false

Varför inlindning fungerar

När [T] placeras till vänster blir den kontrollerade typen en tupel, inte den nakna parametern. Den särskilda distributionsregeln gäller då inte längre, så unionen testas som en helhet.

type AllStrings<T> = [T] extends [string] ? true : false;

type A = AllStrings<"a" | "b">;     // true
type B = AllStrings<"a" | number>;  // false

Med och utan distribution

Jämför de två formerna direkt. Den nakna versionen kontrollerar varje medlem, medan den inlindade versionen kontrollerar unionen som en enda typ.

type Distributed<T> = T extends string ? true : false;
type Wrapped<T> = [T] extends [string] ? true : false;

type A = Distributed<string | number>; // boolean (true | false)
type B = Wrapped<string | number>;     // false

Så fungerar Exclude internt

Det inbyggda verktyget Exclude<T, U> tar bort alla medlemmar från T som kan tilldelas till U. Det är helt enkelt ett distribuerande villkor som mappar matchande medlemmar till never.

type MyExclude<T, U> = T extends U ? never : T;

type A = MyExclude<"a" | "b" | "c", "b">; // "a" | "c"

Så fungerar Extract internt

Extract<T, U> är den omvända motsvarigheten: behåll bara de medlemmar som kan tilldelas till U. Samma distribution, motsatta grenar.

type MyExtract<T, U> = T extends U ? T : never;

type A = MyExtract<"a" | "b" | "c", "a" | "c">; // "a" | "c"

Praktisk kraft

Distribution låter er omforma varje medlem i en union i ett enda uttryck: skapa arrayer av varje medlem, lägg till ett prefix på varje sträng eller filtrera efter struktur. Tillsammans med [T] extends [U] för kontroller av hela unioner kan ni styra exakt när distributionen aktiveras.

Notation: I riktig TypeScript skrivs mallitteraltyper med backtick-avgränsade strängar som innehåller dollar-klammerhål. I dessa kodstycken visar vi det mönstret som Tpl<...>, där varje del listas i ordning. En backtick-mall som matchar det literala prefixet följt av Rest visas till exempel som Tpl<'prefix', infer Rest>.

type Prefix<T extends string> = T extends unknown ? Tpl<'id_', T> : never;
// Tpl<'id_', T> is the template literal type joining 'id_' with each T

type A = Prefix<'a' | 'b'>; // 'id_a' | 'id_b'

Snabbtest

Testa er förståelse av distribuerande villkorstyper.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Distribuerande villkorstyper är motorn bakom verktyg för unioner.

Ett naket T extends U ? distribueras över varje medlem i unionen.
Grenar som returnerar never filtrerar bort medlemmar.
[T] extends [U] inaktiverar distribution vid kontroller av hela unioner.
Exclude och Extract är små distribuerande villkorstyper.

Nästa är kurs 22: aritmetik i typsystemet.

Gratis att börja

Lär dig TypeScript med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 101
Lektioner: 352

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Distributiva villkorstyper” gratis?

Ja – hela texten till ”Distributiva villkorstyper” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i TypeScript Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i TypeScript Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Distributiva villkorstyper”?

Styr hur villkor distribueras över unioner. Ni övar på TypeScript Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig TypeScript Academy?

Du behöver inga förkunskaper. Utbildningen i TypeScript Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Distributiva villkorstyper”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här TypeScript Academy-lektionen?

Ja. Varje TypeScript Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till TypeScript Academy