TypeScript Academy · Lektion

Räkna med tupellängd

Representera tal som tupellängder i typer.

Lektion 1 av 413 steg

Räkna med tupellängd är en gratis lektion i TypeScript Academy på CoddyKit. Detta är lektion 1 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.

Tal behöver en representation

Typsystemet kan inte addera numeriska literaler direkt. Den klassiska lösningen är att representera ett tal N som en tupel med N element. Innehållet spelar ingen roll; det är bara längden som räknas.

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

Läsa av längd

Varje tupeltyp har en length-egenskap som är en numerisk literaltyp. Genom att indexera med ["length"] läser du tillbaka den som ett tal som du kan använda.

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

Varför unknown som utfyllnad

Vi använder unknown som elementtyp eftersom värdena saknar betydelse – det är bara antalet som räknas. Alla typer fungerar, men unknown signalerar tydligt att det är en "platshållare".

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

Bygga en tupel med längden N

Åt andra hållet kan du bygga en tupel med en mållängd genom rekursion. Lägg till element tills längden motsvarar N och returnera sedan tupeln. Detta är den välkända hjälptypen 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]

Så fungerar loopen i BuildTuple

Följ BuildTuple<3>:

Acc-längden är 0, inte 3 – lägg till ett element
Acc-längden är 1, inte 3 – lägg till ett element
Acc-längden är 2, inte 3 – lägg till ett element
Acc-längden är 3, alltså 3 – returnera

Ackumulatorns längd fungerar som loopräknare.

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

Längden är bryggan

Två operationer låter dig gå mellan tal och tupler:

Tal till tupel: BuildTuple<N>
Tupel till tal: T["length"]

All typaritmetik bygger på att korsa den här bron.

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

Jämföra längder

Eftersom tupellängden är en literal kan du kontrollera om antal är lika. Bygg tupler och jämför deras längder genom tilldelningskompatibilitet.

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

En generisk längdräknare

Du kan implementera length på nytt med rekursion för att förstå hur den fungerar, även om det går snabbare att läsa ["length"]. Det visar att räkning bara innebär att gå igenom en tupel.

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

Tupler som räknare

Tänk på tupeln som en räknetavla: varje element är ett streck. När du lägger till ett element ökar antalet, och när du tar bort ett minskar det. Den här mentala modellen gör aritmetiken intuitiv.

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

type A = Inc<3>; // 4

Förhandsvisning av dekrementering

Vid dekrementering byggs tupeln för N. Därefter infereras allt utom det sista elementet, och den kortare längden läses av. Du formaliserar detta i nästa lektion.

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

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

Begränsningar att komma ihåg

Den här tekniken fungerar för små, icke-negativa heltal. Ett mycket stort N når rekursionsgränserna, och det finns inget inbyggt stöd för negativa tal eller decimaltal. Inom dessa gränser är tekniken tillförlitlig och helt statisk.

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

Snabb kontroll

Testa din förståelse av räkning med tupellängder.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Räkning är grunden för matematik på typnivå.

Representera N som en tupel med längden N.
Läs av talet med T["length"].
BuildTuple<N> går från tal till tupel.
Fungerar endast för små, icke-negativa heltal.

Nästa steg: riktig addition och subtraktion.

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 ”Räkna med tupellängd” gratis?

Ja – hela texten till ”Räkna med tupellängd” 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 ”Räkna med tupellängd”?

Representera tal som tupellängder i typer. 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 1 av 4.

Hur lång tid tar lektionen ”Räkna med tupellängd”?

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