TypeScript Academy · Lekcja

Unikanie kosztownych operacji na typach

Identyfikuj i naprawiaj głęboko rekurencyjne lub rozdzielne typy.

Unikanie kosztownych operacji na typach 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.

Co sprawia, że operacja na typach jest kosztowna

Głęboko rekurencyjne typy, duże rozkłady unii i złożone łańcuchy infer zmuszają TypeScript do tworzenia wielu wariantów typów, co powoduje wykładnicze spowolnienia.

// Expensive: distributes over every member of a large union
type FilterStrings<T> = T extends string ? T : never;
type Result = FilterStrings<string | number | boolean | null | undefined | ...>;

Należy unikać nadmiernie dużych unii

Unie zawierające setki elementów (na przykład pochodzących z wielu literałów napisowych) mogą znacznie spowolnić sprawdzanie typów. Warto rozważyć zawężenie dziedziny albo użycie typu string z walidacją.

// Expensive
type HugeUnion = "a" | "b" | "c" | /* 200 more ... */ "z";
// Better: string with a runtime check
function isValid(s: string): s is ValidString { return VALID_SET.has(s); }

Należy preferować interfejsy zamiast złożonych aliasów typów

TypeScript buforuje interfejsy bardziej agresywnie niż przecięcia złożonych aliasów typów. Dla kształtów obiektów używanych w wielu miejscach należy preferować interface.

// Slow: recomputed union intersection each time
type BigObject = TypeA & TypeB & TypeC & TypeD;
// Fast: interface (cached)
interface BigObject extends TypeA, TypeB, TypeC, TypeD {}

Należy ograniczać głębokość rekurencji

Rekurencyjne typy warunkowe są potężne, ale mogą osiągnąć limit głębokości TypeScript (zwykle 100 poziomów). Należy dodać licznik głębokości, aby wcześniej zakończyć obliczenia.

type Flatten<T, Depth extends number[] = []> =
  Depth["length"] extends 10 ? T
  : T extends (infer U)[] ? Flatten<U, [...Depth, 0]>
  : T;

Należy buforować typy pośrednie

Należy nadawać nazwy złożonym typom pośrednim, aby TypeScript mógł je buforować i ponownie wykorzystywać zamiast obliczać je od nowa przy każdym odwołaniu.

// Before: recomputed at each use
type MyResult<T> = T extends SomeComplex<infer U> ? Transform<U> : never;

// After: split into named intermediates
type ExtractU<T> = T extends SomeComplex<infer U> ? U : never;
type MyResult<T> = Transform<ExtractU<T>>;

Należy unikać głębokich typów mapowanych dla dużych obiektów

Zastosowanie DeepReadonly do bardzo dużego typu obiektu powoduje, że TypeScript rekurencyjnie przechodzi przez każdą właściwość, co jest kosztowne.

// Expensive on 50-property nested objects
type Safe = DeepReadonly<HugeConfig>;
// Better: annotate at creation time with const assertions

Należy używać leniwej ewaluacji generyków

Umieszczenie kosztownego typu w thunku (typie funkcji, która go zwraca) odracza jego ewaluację do momentu, gdy typ będzie rzeczywiście potrzebny.

// Lazy evaluation via wrapper
type Lazy<T> = () => T;
type ExpensiveLazy = Lazy<DeepReadonly<HugeConfig>>;

Należy preferować jawne typy zwracane

Jawne adnotowanie typów zwracanych przez funkcje zapobiega wielokrotnemu wywnioskowywaniu ich w każdym miejscu wywołania, przyspieszając sprawdzanie typów.

// Let TypeScript infer (may be slow for complex functions)
function process(data: Input) { return transform(data); }

// Faster: explicit annotation
function process(data: Input): Output { return transform(data); }

isolatedDeclarations na potrzeby równoległego sprawdzania

isolatedDeclarations w TypeScript 5.5+ wymaga jawnych typów zwracanych, umożliwiając równoległe sprawdzanie typów niezależnych plików bez pełnego wnioskowania.

// tsconfig.json
{
  "compilerOptions": {
    "isolatedDeclarations": true
  }
}

Odwołania do projektów na potrzeby izolacji

Odwołania do projektów zapobiegają sprawdzaniu typów niezmienionych pakietów przez TypeScript, co przynosi największe korzyści w dużych monorepozytoriach.

# With project references:
# tsc --build only recompiles packages whose sources changed
# Unchanged packages: declaration files used directly

Podsumowanie: unikanie kosztownych typów

Aby TypeScript działał szybko, należy unikać ogromnych unii, buforować typy pośrednie, preferować interfejsy zamiast złożonych aliasów, ograniczać głębokość rekurencji, używać jawnych typów zwracanych i izolować pakiety za pomocą odwołań do projektów.

Szybkie sprawdzenie

Jakie podejście pomaga TypeScriptowi bardziej agresywnie buforować kształt obiektu?

Czego się Państwo nauczyli

Kosztowne operacje na typach TypeScript obejmują duże unie, głęboką rekurencję i wielokrotne złożone wnioskowanie. Optymalizację można osiągnąć przez buforowanie typów pośrednich, preferowanie interfejsów, ograniczanie rozmiarów unii oraz używanie odwołań do projektów w monorepozytoriach.

Często zadawane pytania

Czy lekcja „Unikanie kosztownych operacji na typach” jest bezpłatna?

Tak — pełny tekst „Unikanie kosztownych operacji na typach” 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 „Unikanie kosztownych operacji na typach”?

Identyfikuj i naprawiaj głęboko rekurencyjne lub rozdzielne typy. Ć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 „Unikanie kosztownych operacji na typach”?

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

Profilowanie powolnej kompilacji TypeScript
Unikanie kosztownych operacji na typach
skipLibCheck i izolowane deklaracje
Sprawdzanie typów w CI: strategie i narzędzia

← Powrót do TypeScript Academy