0Pricing
TypeScript Academy · Lekcja

Porównania na poziomie typów

Porównuj liczby wyłącznie na poziomie typów

Porównania na poziomie typów to bezpłatna lekcja TypeScript Academy na CoddyKit. To lekcja 3 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.

Porównywanie liczb

Aby porównywać typy literałów liczbowych, ponownie korzystamy z krotek. Pomysł polega na jednoczesnym skracaniu obu liczb i sprawdzaniu, która z nich pierwsza osiągnie zero. Mniejsza jest ta liczba, dla której pusta krotka pojawi się wcześniej.

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

Równość literałów

Równość literałów liczbowych opiera się na wzajemnej przypisywalności. Dwa literały są równe, gdy każdy z nich rozszerza drugi. Opakowanie ich w krotki zapobiega niespodziankom związanym z uniami.

type NumEquals<A extends number, B extends number> =
  [A] extends [B] ? ([B] extends [A] ? true : false) : false;

type X = NumEquals<3, 3>; // true
type Y = NumEquals<3, 4>; // false

Sprawdzanie większej wartości przez skracanie

Dla A > B budujemy krotki dla obu liczb i w każdym kroku usuwamy po jednym elemencie z każdej z nich. Jeśli B stanie się pusta, gdy A nadal będzie zawierać elementy, oznacza to, że A jest większe.

type GreaterThan<A extends number, B extends number> =
  BuildTuple<A> extends [...BuildTuple<B>, unknown, ...unknown[]]
    ? true : false;

type X = GreaterThan<5, 3>; // true
type Y = GreaterThan<3, 5>; // false

Jak odczytać ten wzorzec

Wzorzec [...BuildTuple<B>, unknown, ...unknown[]] oznacza: prefiks długości B, a następnie co najmniej jeden dodatkowy element. Jeśli A pasuje do tego wzorca, ma więcej elementów niż B, więc A > B.

type A = GreaterThan<4, 4>; // false (no extra element)
type B = GreaterThan<6, 2>; // true

Mniejsze niż

LessThan to po prostu GreaterThan z zamienionymi argumentami. Należy ponownie użyć istniejącego rozwiązania zamiast wyprowadzać je od początku.

type LessThan<A extends number, B extends number> =
  GreaterThan<B, A>;

type X = LessThan<3, 5>; // true
type Y = LessThan<5, 3>; // false

Większe lub równe

Łączymy porównywanie z równością. A >= B jest prawdziwe, gdy A > B lub A == B.

type Gte<A extends number, B extends number> =
  GreaterThan<A, B> extends true
    ? true
    : NumEquals<A, B>;

type X = Gte<5, 5>; // true
type Y = Gte<3, 5>; // false

Porównywanie rekurencyjne

Alternatywne rozwiązanie porównuje liczby, zmniejszając obie do chwili, gdy jedna z nich osiągnie zero. Wyraźnie pokazuje to ideę działania krok po kroku: mniejsza jest ta liczba, która pierwsza osiągnie zero.

type Cmp<A extends number, B extends number> =
  A extends 0
    ? (B extends 0 ? "eq" : "lt")
    : B extends 0
      ? "gt"
      : Cmp<Dec<A>, Dec<B>>;

type X = Cmp<3, 5>; // "lt"

Zależność od Dec

Wersja rekurencyjna wymaga użycia Dec z poprzedniej lekcji. W każdym kroku usuwamy jedną kreskę z każdej strony. Gdy obie wartości wynoszą zero, są równe; jeśli tylko jedna wynosi zero, druga jest większa.

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

Równość a przypisywalność

Należy zachować ostrożność: number extends number jest prawdą, ale nie oznacza równości literałów. Opisywane porównania zakładają konkretne typy literałów, takie jak 3 i 5, a nie szeroki typ number.

type A = NumEquals<3, 3>;          // true
type B = 3 extends number ? 1 : 0; // 1 (assignability, not equality)

Budowanie klucza sortowania

Za pomocą porównywania można kodować reguły porządku. Można na przykład określić na poziomie typów, czy krotka dwóch liczb jest posortowana rosnąco.

type IsSorted<A extends number, B extends number> =
  GreaterThan<A, B> extends true ? false : true;

type X = IsSorted<2, 5>; // true
type Y = IsSorted<5, 2>; // false

Używać oszczędnie

Porównywanie wymaga rekurencji. Świetnie nadaje się do sprawdzania małych wartości o ograniczonym zakresie, takich jak indeksy i stałe limity, ale nie jest ogólną biblioteką numeryczną. Należy utrzymywać małe operandy i preferować postać opartą na wzorcu prefiksu, która jest płytsza niż pełna rekurencja krokowa.

type A = GreaterThan<9, 4>; // true (cheap, prefix pattern)

Szybki test

Proszę sprawdzić swoje rozumienie porównań na poziomie typów.

Podsumowanie

Potrafią już Państwo porządkować liczby w systemie typów.

  • Równość uzyskujemy dzięki wzajemnej przypisywalności literałów.
  • GreaterThan opiera się na prefiksie długości B i dodatkowym elemencie.
  • LessThan zamienia argumenty, a Gte dodaje równość.
  • Rozwiązanie działa dla małych liczb będących literałami, ale nie dla szerokiego typu number.

Następnie: przekształcanie tych mechanizmów w praktyczne narzędzia.

Często zadawane pytania

Czy lekcja „Porównania na poziomie typów” jest bezpłatna?

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

Porównuj liczby wyłącznie na poziomie typów Ć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 3 z 4.

Ile czasu zajmuje lekcja „Porównania 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