TypeScript Academy · Les

Tellen met tuplelengte

Representeren getallen in typen als tuplelengtes

Les 1 van 413 stappen

Tellen met tuplelengte is een gratis TypeScript Academy-les op CoddyKit. Dit is les 1 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.

Getallen hebben een representatie nodig

Het typesysteem kan numerieke waarden niet rechtstreeks optellen. De klassieke oplossing is om een getal N weer te geven als een tuple met N elementen. De inhoud doet er niet toe; alleen de lengte telt.

type Three = [unknown, unknown, unknown];
type N = Three["length"]; // 3

Lengte uitlezen

Elk tupletype heeft een eigenschap length die een numeriek letterlijk type is. Door met ["length"] te indexeren, lees je die als een getal uit dat je kunt gebruiken.

type A = [1, 2, 3, 4]["length"]; // 4
type B = []["length"];           // 0
type C = ["x"]["length"];        // 1

Waarom unknown als opvulling

We gebruiken unknown als elementtype, omdat de waarden niet relevant zijn en alleen de telling telt. Elk type werkt, maar unknown maakt duidelijk dat het om een tijdelijke waarde gaat.

type Two = [unknown, unknown];
type N = Two["length"]; // 2

Een tuple met lengte N bouwen

De omgekeerde bewerking bereik je door met recursie een tuple met de gewenste lengte te bouwen. Voeg elementen toe totdat de lengte overeenkomt met N en geef daarna de tuple terug. Dit is de bekende hulpbewerking BuildTuple.

type BuildTuple<N extends number, Acc extends unknown[] = []> =
  Acc["length"] extends N ? Acc : BuildTuple<N, [...Acc, unknown]>;

type A = BuildTuple<3>; // [unknown, unknown, unknown]

Hoe BuildTuple herhaalt

Volg BuildTuple<3>:

Lengte van Acc is 0, niet 3, voeg er één toe
Lengte van Acc is 1, niet 3, voeg er één toe
Lengte van Acc is 2, niet 3, voeg er één toe
Lengte van Acc is 3, gelijk aan 3, geef de tuple terug

De lengte van de accumulator is de lusteller.

type A = BuildTuple<2>; // [unknown, unknown]

Lengte is de brug

Met twee bewerkingen kun je tussen getallen en tuples schakelen:

Getal naar tuple: BuildTuple<N>
Tuple naar getal: T["length"]

Alle rekenkundige bewerkingen op typen bouwen voort op het oversteken van deze brug.

type FromN = BuildTuple<4>;        // tuple of length 4
type BackToN = FromN["length"];    // 4

Vergelijken op lengte

Omdat de tuplelengte een letterlijke waarde is, kun je controleren of tellingen gelijk zijn. Bouw tuples en vergelijk hun lengtes via toewijsbaarheid.

type SameLength<A extends unknown[], B extends unknown[]> =
  A["length"] extends B["length"] ? true : false;

type X = SameLength<[1, 2], ["a", "b"]>;   // true
type Y = SameLength<[1], ["a", "b"]>;      // false

Een generieke lengteteller

Je kunt length met recursie opnieuw implementeren om te begrijpen hoe het werkt, hoewel ["length"] uitlezen sneller is. Dit laat zien dat tellen gewoon neerkomt op het doorlopen van een tuple.

type Len<T extends unknown[], Acc extends unknown[] = []> =
  T extends [unknown, ...infer R]
    ? Len<R, [...Acc, unknown]>
    : Acc["length"];

type A = Len<["a", "b", "c"]>; // 3

Tuples als tellers

Zie de tuple als een turflijst: elk element is één streep. Een element toevoegen verhoogt de teller; er één verwijderen verlaagt hem. Met dit denkmodel wordt rekenen intuïtief.

type Inc<N extends number> = [...BuildTuple<N>, unknown]["length"];

type A = Inc<3>; // 4

Vooruitblik op verlagen

Verlagen bouwt de tuple voor N, leidt vervolgens alles behalve het laatste element af en leest de kortere lengte uit. In de volgende les werk je dit formeel uit.

type Dec<N extends number> =
  BuildTuple<N> extends [unknown, ...infer R] ? R["length"] : 0;

type A = Dec<3>; // 2
type B = Dec<0>; // 0

Beperkingen om te onthouden

Deze techniek werkt voor kleine niet-negatieve gehele getallen. Bij een zeer grote N worden de recursielimieten bereikt en er is geen ingebouwde ondersteuning voor negatieve getallen of decimalen. Binnen deze grenzen is de techniek betrouwbaar en volledig statisch.

type A = BuildTuple<5>["length"]; // 5 (fine)
// BuildTuple<10000> would error: too deep

Korte controle

Toets je begrip van tellen met tuplelengtes.

Beantwoord dit in de interactieve les

Samenvatting

Tellen vormt de basis van rekenen op typeniveau.

Representeer N als een tuple met lengte N.
Lees het getal uit met T["length"].
BuildTuple<N> zet een getal om in een tuple.
Werkt alleen voor kleine niet-negatieve gehele getallen.

Hierna: echt optellen en aftrekken.

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Tellen met tuplelengte” gratis?

Ja — de volledige tekst van “Tellen met tuplelengte” 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 “Tellen met tuplelengte”?

Representeren getallen in typen als tuplelengtes 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 1 van 4.

Hoe lang duurt de les “Tellen met tuplelengte”?

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

← Terug naar TypeScript Academy