Distributieve conditionele typen
Bepaal hoe conditionals over unions worden verdeeld
Distributieve conditionele typen is een gratis TypeScript Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject TypeScript Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus TypeScript Academy bevat in totaal 4 lessen.
Een verrassend gedrag
Voorwaardelijke typen hebben één speciale regel: wanneer het gecontroleerde type een onverpakt typeparameter is en je een unie doorgeeft, wordt het voorwaardelijke type afzonderlijk over elk lid verdeeld en worden de resultaten daarna samengevoegd tot een unie.
Dit vormt de basis van Exclude, Extract en veel andere hulpprogramma's.
type ToArray<T> = T extends unknown ? T[] : never;
type A = ToArray<string | number>;
// string[] | number[] (NOT (string | number)[])Wat 'onverpakt' betekent
'Onverpakt' betekent dat de typeparameter op zichzelf links van extends staat en niet in een ander type is verpakt. Distributie vindt alleen plaats bij onverpakte parameters.
type Naked<T> = T extends string ? "y" : "n";
// T is naked -> distributes over unionsDistributie stap voor stap
Voor ToArray<string | number> evalueert de compiler elk lid:
ToArray<string>= string[]ToArray<number>= number[]
Daarna voegt hij ze samen tot een unie: string[] | number[].
type R = ToArray<boolean>;
// boolean is true | false, so:
// true[] | false[]Een unie filteren
Door distributie wordt filteren eenvoudig. Zet ongewenste leden om naar never; never verdwijnt uit een unie, zodat alleen de behouden leden overblijven.
type Strings<T> = T extends string ? T : never;
type A = Strings<string | number | boolean>; // stringnever verdwijnt uit unies
Een belangrijk feit: X | never wordt vereenvoudigd tot X. Wanneer een verdeelde vertakking dus never oplevert, wordt dat lid effectief uit de uiteindelijke unie verwijderd.
type A = string | never; // string
type B = "a" | never | "b"; // "a" | "b"Distributie uitschakelen
Soms wil je geen distributie, bijvoorbeeld wanneer je een volledige unie als één geheel vergelijkt. Verpak beide kanten in een tuple met één element: [T] extends [U]. T is nu niet meer onverpakt, dus distributie is uitgeschakeld.
type IsNever<T> = [T] extends [never] ? true : false;
type A = IsNever<never>; // true
type B = IsNever<string>; // falseWaarom verpakken werkt
Doordat je links [T] plaatst, is het gecontroleerde type een tuple en niet de losse parameter. De speciale distributieregel is niet meer van toepassing, dus de unie wordt als geheel gecontroleerd.
type AllStrings<T> = [T] extends [string] ? true : false;
type A = AllStrings<"a" | "b">; // true
type B = AllStrings<"a" | number>; // falseMet en zonder distributie
Vergelijk de twee vormen rechtstreeks. De onverpakte versie controleert elk lid; de verpakte versie controleert de unie als één type.
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>; // falseDe interne werking van Exclude
Het ingebouwde Exclude<T, U> verwijdert uit T elk lid dat toewijsbaar is aan U. Het is gewoon een distributief voorwaardelijk type dat overeenkomende leden omzet naar never.
type MyExclude<T, U> = T extends U ? never : T;
type A = MyExclude<"a" | "b" | "c", "b">; // "a" | "c"De interne werking van Extract
Extract<T, U> werkt omgekeerd: het houdt alleen de leden over die toewijsbaar zijn aan U. Dezelfde distributie, maar met tegenovergestelde vertakkingen.
type MyExtract<T, U> = T extends U ? T : never;
type A = MyExtract<"a" | "b" | "c", "a" | "c">; // "a" | "c"Praktische kracht
Met distributie kun je elk lid van een unie in één expressie transformeren: voor elk lid een array bouwen, elke string van een voorvoegsel voorzien of op structuur filteren. In combinatie met [T] extends [U] voor controles van volledige unies bepaal je precies wanneer distributie plaatsvindt.
Notatie: in echte TypeScript schrijft je sjabloonletterlijke typen met strings die door backticks worden afgebakend en gaten met dollaraccenten bevatten. In deze fragmenten geven we dat patroon weer als Tpl<...> en vermelden we elk deel in de juiste volgorde; bijvoorbeeld verschijnt een backticksjabloon die overeenkomt met het letterlijke voorvoegsel en daarna Rest als 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'Korte toets
Toets je begrip van distributieve voorwaardelijke typen.
Samenvatting
Distributieve voorwaardelijke typen vormen de motor achter hulpprogramma's voor unies.
- Een onverpakte
T extends U ?wordt over elk lid van een unie verdeeld. - Vertakkingen die
neverteruggeven, filteren leden weg. [T] extends [U]schakelt distributie uit voor controles van volledige unies.ExcludeenExtractzijn kleine distributieve voorwaardelijke typen.
Vervolgens in cursus 22: rekenen in het typesysteem.
Leer TypeScript met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 101
- Lessen
- 352
Veelgestelde vragen
Is de les “Distributieve conditionele typen” gratis?
Ja — de volledige tekst van “Distributieve conditionele typen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus TypeScript Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus TypeScript Academy bevat in totaal 4 lessen.
Wat leer ik in “Distributieve conditionele typen”?
Bepaal hoe conditionals over unions worden verdeeld Je oefent met TypeScript Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met TypeScript Academy te beginnen?
Ervaring vooraf is niet nodig. TypeScript Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.
Hoe lang duurt de les “Distributieve conditionele typen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over TypeScript Academy?
Ja. Elke les over TypeScript Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Typen als rekentaal
- Conditionals op typeniveau
- Recursie op typeniveau
- Distributieve conditionele typen