0Pricing
TypeScript Academy · Lekcja

Praktyczne narzędzia typów liczbowych

Stosuj arytmetykę typów do ograniczeń zakresu i długości

Praktyczne narzędzia typów liczbowych to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 4 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.

Od teorii do narzędzi

Arytmetyka i porównywanie stają się użyteczne, gdy zapakujemy je w praktyczne narzędzia: zakresy, tablice o wymuszanej długości i ograniczane indeksy. W tej lekcji przekształcimy podstawowe operacje w rozwiązania, które można rzeczywiście wdrożyć.

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

Enumerate: od 0 do N-1

Podstawowy typ pomocniczy tworzy unię wszystkich liczb od 0 do N-1. Należy zbudować krotkę o długości N i odczytać wszystkie indeksy jej kluczy.

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

type A = Enumerate<4>; // 0 | 1 | 2 | 3

Typy zakresów

Range<Start, End> zwraca liczby od Start do End - 1. Należy pobrać Enumerate<End> i wykluczyć wartości mniejsze niż Start.

type Range<S extends number, E extends number> =
  Exclude<Enumerate<E>, Enumerate<S>>;

type A = Range<2, 6>; // 2 | 3 | 4 | 5

Ograniczanie parametru

Zakresu można użyć do ograniczenia prawidłowych argumentów. Funkcja przyjmująca tylko niewielki wynik rzutu kostką może przyjmować Range<1, 7>, dzięki czemu kompilator odrzuci wartości spoza zakresu.

type DiceFace = Range<1, 7>; // 1|2|3|4|5|6
declare function roll(face: DiceFace): void;
roll(4); // ok
// roll(8); // compile error

Wymuszanie długości tablicy

Typ tablicy o stałej długości odrzuca tablice o niewłaściwym rozmiarze. Należy za pomocą rekurencji zbudować krotkę złożoną z N elementów typu T.

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

type RGB = FixedArray<number, 3>; // [number, number, number]

Używanie stałej długości

Od tej pory nieprawidłowe użycie powoduje błąd kompilacji. Punkt w przestrzeni 3D musi mieć dokładnie trzy współrzędne.

type Vec3 = FixedArray<number, 3>;
const v: Vec3 = [1, 2, 3]; // ok
// const w: Vec3 = [1, 2]; // error: missing element

Ograniczanie indeksów

Typ indeksu można ograniczyć do prawidłowych pozycji w tablicy. Należy połączyć długość krotki z Enumerate, aby akceptowane były tylko indeksy mieszczące się w zakresie.

type Indices<T extends readonly unknown[]> = Enumerate<T["length"]>;

type Arr = readonly ["a", "b", "c"];
type I = Indices<Arr>; // 0 | 1 | 2

Bezpieczny dostęp indeksowany

Mając typ prawidłowych indeksów, można napisać funkcję pobierającą, której parametr indeksu nie może wyjść poza zakres. Dzięki temu błędy o jeden element są wykrywane w czasie kompilacji.

declare function at<T extends readonly unknown[]>(
  arr: T,
  i: Indices<T>
): T[Indices<T>];

const x = at(["a", "b", "c"] as const, 2); // ok
// at(["a", "b", "c"] as const, 3); // error

Typy pomocnicze Min i Max

Na tej podstawie można dodać porównywanie, aby wybierać większą lub mniejszą z dwóch liczb — jest to przydatne przy ograniczaniu wartości do zakresu.

type Max<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? A : B;
type Min<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? B : A;

type X = Max<3, 8>; // 8
type Y = Min<3, 8>; // 3

Łączenie narzędzi

Te narzędzia można łączyć. Krotka o długości mieszczącej się w zakresie, indeks ograniczony do rozmiaru tablicy i wartość ograniczona przez minimum oraz maksimum — każde z nich jest małą, wielokrotnego użytku funkcją na poziomie typów.

type ValidPort = Range<1, 4>; // 1 | 2 | 3 (toy example)
type Slots = FixedArray<ValidPort, 2>; // [1|2|3, 1|2|3]

Kiedy warto

Arytmetyka typów sprawdza się przy małych, stałych ograniczeniach: krotkach RGB, ściankach kostki, współrzędnych planszy i rozmiarach pól protokołu. Nie warto jej stosować dla dużych lub dynamicznych liczb, gdy limity rekurencji i złożoność przeważają nad korzyściami związanymi z bezpieczeństwem. Należy po nią sięgać, gdy ograniczenie jest małe, a gwarancja daje istotną wartość.

type Board = FixedArray<FixedArray<0 | 1, 3>, 3>; // 3x3 grid

Szybki test

Proszę sprawdzić swoje rozumienie praktycznych narzędzi numerycznych.

Podsumowanie

Zbudowali Państwo niewielką bibliotekę narzędzi numerycznych na poziomie typów.

  • Enumerate i Range tworzą unie liczb.
  • FixedArray wymusza dokładne długości.
  • Indices ogranicza dostęp do prawidłowych pozycji.
  • Min/Max wyznaczają granice wartości.

Należy używać ich dla małych, stałych ograniczeń. Następny jest kurs 23: symulowanie typów wyższego rodzaju.

Często zadawane pytania

Czy lekcja „Praktyczne narzędzia typów liczbowych” jest bezpłatna?

Tak — pełny tekst „Praktyczne narzędzia typów liczbowych” 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 „Praktyczne narzędzia typów liczbowych”?

Stosuj arytmetykę typów do ograniczeń zakresu i długości Ć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 4 z 4.

Ile czasu zajmuje lekcja „Praktyczne narzędzia typów liczbowych”?

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