TypeScript Academy · Lekcja

Typy jako język obliczeń

Zrozum system typów jako czysty język funkcyjny

Typy jako język obliczeń 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.

Typy są językiem

TypeScript zawiera dwa języki działające obok siebie. Jeden to znany już JavaScript na poziomie wartości. Drugi to poziom typów, który działa wyłącznie w czasie kompilacji. W tym kursie nauczy się Pan/Pani programować w tym drugim języku.

System typów jest małym, czystym językiem funkcyjnym. Podaje mu się typy jako dane wejściowe, a on oblicza typy jako dane wyjściowe. Nic z tego nie trafia do środowiska uruchomieniowego.

type Greeting = "hello";
type Loud = Uppercase<Greeting>;
// Loud is "HELLO" - computed by the type system

Typy na wejściu, typy na wyjściu

Typ generyczny jest zasadniczo funkcją odwzorowującą typy na typy. Parametr typu jest argumentem, a ciało jest wartością zwracaną.

Poniżej Boxed przyjmuje typ T i tworzy typ obiektu, który go opakowuje. Należy myśleć o T jak o parametrze przekazywanym do funkcji.

type Boxed<T> = { value: T };

type A = Boxed<number>; // { value: number }
type B = Boxed<string>; // { value: string }

Generyki są funkcjami

Proszę porównać funkcję na poziomie wartości z funkcją na poziomie typów. Ich kształty są niemal identyczne: parametry na wejściu i pojedynczy wynik na wyjściu.

Wartość: const id = (x) => x
Typ: type Id<T> = T

Identyfikator typów Id po prostu zwraca to, co zostanie do niego przekazane.

type Id<T> = T;

type X = Id<boolean>; // boolean
type Y = Id<"abc">;  // "abc"

Brak kosztu w czasie wykonywania

Wszystko na poziomie typów jest usuwane, zanim kod zostanie uruchomiony. Wynikowy kod JavaScript nie zawiera żadnych śladów obliczeń typów. Niezależnie od złożoności typów uruchomiony program nie ponosi z tego powodu żadnego kosztu wydajnościowego.

Dlatego programowanie na poziomie typów bywa nazywane darmowym: wpływa wyłącznie na kompilator, a nigdy na pakiet wynikowy.

type Pair<T> = [T, T];
const p: Pair<number> = [1, 2];
// Compiled JS is just: const p = [1, 2];
console.log(p);

Wiele parametrów

Funkcje na poziomie typów mogą przyjmować kilka parametrów, podobnie jak zwykłe funkcje. W tym przypadku Merge przyjmuje dwa typy obiektów i je łączy.

Należy odczytać to następująco: dla danych A i B zwracany jest obiekt zawierający wszystkie właściwości obu typów.

type Merge<A, B> = A & B;

type User = { id: number };
type Named = { name: string };
type NamedUser = Merge<User, Named>;
// { id: number; name: string }

Wartości domyślne parametrów

Parametry typów mogą mieć wartości domyślne, dokładnie tak jak domyślne argumenty funkcji. Jeśli wywołujący pominie argument, zostanie użyta wartość domyślna.

type List<T = string> = T[];

type A = List;        // string[]
type B = List<number>; // number[]

Ograniczenia działają jak zabezpieczenia

Ograniczenie z extends określa, jakie typy można przekazać. Jest typowym odpowiednikiem sprawdzenia argumentu funkcji przed jego użyciem.

HasId akceptuje tylko typy, które mają już właściwość id, więc ciało funkcji może bezpiecznie ją odczytać.

type GetId<T extends { id: number }> = T["id"];

type A = GetId<{ id: number; name: string }>; // number
// GetId<{ name: string }> would be a compile error

Obliczenia, nie tylko adnotacje

Początkujący używają typów tylko do oznaczania wartości. Programowanie na poziomie typów wykorzystuje typy do obliczania wyników. Wbudowane narzędzie ReturnType analizuje na przykład typ funkcji i wyodrębnia typ jej wyniku.

type Fn = (a: number) => string;
type R = ReturnType<Fn>; // string

type Fn2 = () => boolean;
type R2 = ReturnType<Fn2>; // boolean

Mapowanie właściwości

Typy mapowane pozwalają przekształcić każdą właściwość typu obiektu. Jest to pętla w języku typów. Stringify zamienia każdy typ wartości na string.

type Stringify<T> = { [K in keyof T]: string };

type Input = { a: number; b: boolean };
type Out = Stringify<Input>; // { a: string; b: string }

Czysty i deterministyczny

Język typów jest czysty: te same dane wejściowe zawsze dają ten sam typ wynikowy, bez skutków ubocznych. Nie ma w nim mutacji, operacji wejścia/wyjścia ani zależności od czasu. Ta czystość sprawia, że programy na poziomie typów są przewidywalne i można je łączyć.

Dzięki czystości o typach rozumuje się tak jak o matematyce: przez podstawianie.

type Square<T extends { area: number }> = T["area"];
// Always the same result for the same input shape

Dlaczego to ma znaczenie

Opanowanie tego drugiego języka pozwala zakodować reguły, które kompilator egzekwuje automatycznie: poprawne ścieżki, kompletne instrukcje switch, bezpieczne operacje na ciągach znaków oraz interfejsy API, których nie można użyć nieprawidłowo. W dalszej części tego kursu zbudują Państwo zestaw takich narzędzi.

Najważniejsza zasada: typ to wartość w języku typów, a generyk to funkcja.

type NonEmpty<T extends unknown[]> =
  T extends [unknown, ...unknown[]] ? T : never;
// Encodes a rule: the tuple must have at least one element

Szybkie sprawdzenie

Proszę sprawdzić rozumienie typów jako języka obliczeń.

Podsumowanie

Poznali Państwo fakt, że typy TypeScriptu tworzą czysty język funkcyjny uruchamiany na etapie kompilacji.

Generyki są funkcjami: przyjmują typy i zwracają typy.
Parametry obsługują wartości domyślne i ograniczenia extends.
Typy mapowane przechodzą w pętli po właściwościach.
Wszystko jest usuwane, więc nie ma kosztu w czasie wykonywania.

Następnie język ten otrzyma instrukcję if: typy warunkowe.

Często zadawane pytania

Czy lekcja „Typy jako język obliczeń” jest bezpłatna?

Tak — pełny tekst „Typy jako język obliczeń” 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 „Typy jako język obliczeń”?

Zrozum system typów jako czysty język funkcyjny Ć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 „Typy jako język obliczeń”?

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

← Powrót do TypeScript Academy