0Pricing
TypeScript Academy · Lekcja

Dodawanie i odejmowanie na poziomie typów

Buduj operacje arytmetyczne za pomocą manipulacji krotkami

Dodawanie i odejmowanie na poziomie typów to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 2 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.

Arytmetyka za pomocą długości

W reprezentacji opartej na długości krotki dodawanie staje się konkatenacją, a odejmowanie — usuwaniem prefiksu. Obliczenia wykonujemy na krotkach, a następnie odczytujemy długość wyniku.

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

Dodawanie

Aby obliczyć A + B, należy zbudować krotkę o długości A, zbudować krotkę o długości B, rozpakować obie do nowej krotki i odczytać jej długość.

type Add<A extends number, B extends number> =
  [...BuildTuple<A>, ...BuildTuple<B>]["length"];

type S = Add<3, 4>; // 7

Dlaczego konkatenacja oznacza dodawanie

Krotka o długości 3, po której następuje krotka o długości 4, daje krotkę o długości 7. Połączenie kresek z dwóch liczników tworzy jeden wspólny licznik, dlatego długości się dodają.

type A = Add<2, 2>; // 4
type B = Add<0, 5>; // 5
type C = Add<1, 6>; // 7

Odejmowanie za pomocą prefiksu

Aby obliczyć A - B, należy zbudować krotkę o długości A, a następnie wywnioskować ją jako prefiks długości B, po którym następuje reszta. Element rest ma długość A - B.

type Sub<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, ...infer Rest]
    ? Rest["length"]
    : never;

type D = Sub<7, 4>; // 3

Odejmowanie krok po kroku

Dla Sub<7, 4> budujemy krotkę długości 7, dopasowujemy prefiks długości 4, przechwytujemy Rest o długości 3 i odczytujemy jego długość. Usunięty prefiks zawiera dokładnie B kresek.

type A = Sub<5, 2>; // 3
type B = Sub<4, 4>; // 0

Niedomiar zwraca never

Liczby na poziomie typów są tutaj nieujemne. Jeśli B > A, nie istnieje prawidłowy prefiks, wzorzec nie zostaje dopasowany, a wynikiem jest never. W razie potrzeby można ustawić wartość domyślną na 0.

type A = Sub<2, 5>; // never

type SubSafe<A extends number, B extends number> =
  [Sub<A, B>] extends [never] ? 0 : Sub<A, B>;
type B = SubSafe<2, 5>; // 0

Inkrementacja i dekrementacja

Szczególne przypadki dodawania i odejmowania jedynki występują na tyle często, że warto nadać im nazwy. Inc dołącza jeden element, a Dec usuwa jeden.

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

type A = Inc<4>; // 5
type B = Dec<4>; // 3

Mnożenie przez powtarzanie

Mnożenie jest wielokrotnym dodawaniem. Dodajemy B do akumulatora A razy, odliczając w dół za pomocą Dec i gromadząc wynik za pomocą Add.

type Mul<A extends number, B extends number, Acc extends number = 0> =
  A extends 0 ? Acc : Mul<Dec<A>, B, Add<Acc, B>>;

type A = Mul<3, 4>; // 12

Pomocniczy typ BuildTuple

Każda z opisanych operacji zależy od BuildTuple. Jest to jedyna wielokrotnego użytku podstawowa operacja: podajemy jej liczbę i otrzymujemy krotkę o tej długości. Należy trzymać ją w jednym miejscu, a na niej budować pozostałe elementy.

type Five = BuildTuple<5>; // [unknown, unknown, unknown, unknown, unknown]
type N = Five["length"];   // 5

Łączenie operacji

Ponieważ każda operacja przyjmuje liczbę i zwraca liczbę, można je swobodnie łączyć. Można pisać wyrażenia takie jak Add<Mul<2, 3>, 4>, a kompilator je obliczy.

type Result = Add<Mul<2, 3>, 4>; // 10

Praktyczne ostrzeżenie

Te sztuczki świetnie sprawdzają się przy małych licznościach: indeksach tablic, stałych rozmiarach i ograniczonych zakresach. W przypadku dużych liczb lub ogólnej arytmetyki limity rekurencji i brak liczb ujemnych sprawiają, że stają się niepraktyczne. Należy ich używać tam, gdzie wartości pozostają małe i statyczne.

type A = Add<8, 7>;  // 15 (fine)
// Add<5000, 5000> would exceed recursion limits

Szybki test

Proszę sprawdzić swoje rozumienie arytmetyki na poziomie typów.

Podsumowanie

Zaimplementowali Państwo arytmetykę w systemie typów.

  • Add: konkatenacja krotek i odczyt długości
  • Sub: wywnioskowanie prefiksu i odczyt długości reszty
  • Inc/Dec to wersje jednoetapowe
  • BuildTuple jest wspólną podstawową operacją

Następnie: porównywanie liczb na poziomie typów.

Często zadawane pytania

Czy lekcja „Dodawanie i odejmowanie na poziomie typów” jest bezpłatna?

Tak — pełny tekst „Dodawanie i odejmowanie na poziomie typów” 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 „Dodawanie i odejmowanie na poziomie typów”?

Buduj operacje arytmetyczne za pomocą manipulacji krotkami Ć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 2 z 4.

Ile czasu zajmuje lekcja „Dodawanie i odejmowanie na poziomie typów”?

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