0Pricing
TypeScript Academy · Lekcja

Liczenie za pomocą długości krotek

Reprezentuj liczby jako długości krotek w typach

Liczenie za pomocą długości krotek to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej TypeScript Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Liczby potrzebują reprezentacji

System typów nie potrafi bezpośrednio dodawać literałów liczbowych. Klasyczne obejście polega na reprezentowaniu liczby N jako krotki zawierającej N elementów. Zawartość nie ma znaczenia; liczy się tylko długość.

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

Odczytywanie długości

Każdy typ krotki ma właściwość length, która jest typem literału liczbowego. Indeksowanie za pomocą ["length"] odczytuje ją z powrotem jako liczbę, której można użyć.

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

Dlaczego wypełniacz unknown

Używamy unknown jako typu elementów, ponieważ wartości nie mają znaczenia — liczy się tylko ich liczba. Można użyć dowolnego typu, ale unknown jasno sygnalizuje „placeholder”.

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

Budowanie krotki o długości N

Aby wykonać operację odwrotną, należy za pomocą rekurencji zbudować krotkę o docelowej długości. Dodajemy elementy, aż długość będzie równa N, a następnie zwracamy krotkę. Jest to znany pomocniczy typ 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]

Jak działa pętla BuildTuple

Prześledźmy działanie BuildTuple<3>:

  • Długość akumulatora wynosi 0, więc nie jest równa 3 — dodajemy jeden element
  • Długość akumulatora wynosi 1, więc nie jest równa 3 — dodajemy jeden element
  • Długość akumulatora wynosi 2, więc nie jest równa 3 — dodajemy jeden element
  • Długość akumulatora wynosi 3, więc jest równa 3 — zwracamy wynik

Długość akumulatora pełni funkcję licznika pętli.

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

Długość jest mostem

Dwie operacje pozwalają przechodzić między liczbami a krotkami:

  • Liczba na krotkę: BuildTuple<N>
  • Krotka na liczbę: T["length"]

Cała arytmetyka na poziomie typów opiera się na przekraczaniu tego mostu.

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

Porównywanie długości

Ponieważ długość krotki jest literałem, można sprawdzać równość liczności. Należy zbudować krotki i porównać ich długości za pomocą przypisywalności.

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

Ogólny licznik długości

Można odtworzyć działanie length za pomocą rekurencji, aby lepiej je zrozumieć, choć odczyt ["length"] jest szybszy. Pokazuje to, że zliczanie polega po prostu na przechodzeniu po krotce.

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

Krotki jako liczniki

Proszę myśleć o krotce jak o liczniku: każdy element to jedna kreska. Dodanie elementu zwiększa wartość o jeden, a usunięcie zmniejsza ją o jeden. Ten model mentalny ułatwia intuicyjne rozumienie arytmetyki.

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

type A = Inc<3>; // 4

Zapowiedź dekrementacji

Dekrementacja buduje krotkę dla N, następnie wywnioskowuje z niej wszystko oprócz ostatniego elementu i odczytuje długość krótszej krotki. W następnej lekcji zostanie to sformalizowane.

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

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

Ograniczenia, o których należy pamiętać

Technika ta działa dla małych nieujemnych liczb całkowitych. Bardzo duże wartości N prowadzą do osiągnięcia limitów rekurencji, a TypeScript nie ma wbudowanej obsługi liczb ujemnych ani dziesiętnych. W tych granicach rozwiązanie jest niezawodne i w pełni statyczne.

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

Szybki test

Proszę sprawdzić swoje rozumienie zliczania długości krotek.

Podsumowanie

Zliczanie jest podstawą arytmetyki na poziomie typów.

  • Reprezentujemy N jako krotkę o długości N.
  • Odczytujemy liczbę za pomocą T["length"].
  • BuildTuple<N> przekształca liczbę w krotkę.
  • Rozwiązanie działa tylko dla małych nieujemnych liczb całkowitych.

Następnie: rzeczywiste dodawanie i odejmowanie.

Często zadawane pytania

Czy lekcja „Liczenie za pomocą długości krotek” jest bezpłatna?

Tak — pełny tekst „Liczenie za pomocą długości krotek” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu TypeScript Academy, przejdź na CoddyKit PRO. Kurs TypeScript Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Liczenie za pomocą długości krotek”?

Reprezentuj liczby jako długości krotek w typach Ćwiczysz TypeScript Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć TypeScript Academy?

Nie wymagamy żadnego doświadczenia. TypeScript Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Liczenie za pomocą długości krotek”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji TypeScript Academy?

Tak. Każda lekcja TypeScript Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Liczenie za pomocą długości krotek
  2. Dodawanie i odejmowanie na poziomie typów
  3. Porównania na poziomie typów
  4. Praktyczne narzędzia typów liczbowych
← Powrót do TypeScript Academy