TypeScript Academy · Lekcja

DeepPartial i DeepReadonly

Buduj rekurencyjne wersje Partial i Readonly.

DeepPartial i DeepReadonly 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.

Dlaczego głębokie typy narzędziowe

Wbudowane typy Partial i Readonly działają tylko na jednym poziomie zagnieżdżenia. W przypadku zagnieżdżonych obiektów potrzebne są ich wersje rekurencyjne.

interface Config {
  db: { host: string; port: number };
  app: { name: string };
}
type Shallow = Partial<Config>;
// Shallow.db is still required — only top level is optional

Implementowanie DeepPartial

Mapuj rekurencyjnie właściwości obiektu, ustawiając każdą z nich jako opcjonalną i rekurencyjnie stosując DeepPartial, jeśli wartością właściwości jest obiekt.

type DeepPartial<T> = T extends object
  ? { [K in keyof T]?: DeepPartial<T[K]> }
  : T;

DeepPartial w praktyce

Zastosuj DeepPartial do zagnieżdżonego typu konfiguracji i zobacz, jak wszystkie poziomy stają się opcjonalne.

type PartialConfig = DeepPartial<Config>;
// PartialConfig.db?: { host?: string; port?: number }

const c: PartialConfig = { db: { host: "localhost" } };
// No error — all other fields are optional

Implementowanie DeepReadonly

Ustaw readonly dla każdej właściwości na każdym poziomie zagnieżdżenia, rekurencyjnie przechodząc do zagnieżdżonych typów obiektowych.

type DeepReadonly<T> = T extends object
  ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T;

DeepReadonly w praktyce

Głęboko zamrożonej konfiguracji nie można modyfikować na żadnym poziomie.

type ReadonlyConfig = DeepReadonly<Config>;
const cfg: ReadonlyConfig = { db: { host: "localhost", port: 5432 }, app: { name: "my-app" } };
// cfg.db.port = 3000; // Error: readonly

Obsługa tablic w głębokich typach

Tablice wymagają specjalnej obsługi — mapuj rekurencyjnie typy elementów, zamiast traktować tablice jak zwykłe obiekty.

type DeepPartial<T> =
  T extends (infer U)[]
    ? DeepPartial<U>[]
    : T extends object
      ? { [K in keyof T]?: DeepPartial<T[K]> }
      : T;

Obsługa typów prostych

Przypadek bazowy rekurencji musi zwracać typy proste bez zmian, a nie opakowane w mapowany typ obiektowy.

type DeepReadonly<T> =
  T extends string | number | boolean | null | undefined ? T
  : T extends (infer U)[] ? ReadonlyArray<DeepReadonly<U>>
  : { readonly [K in keyof T]: DeepReadonly<T[K]> };

Łączenie DeepPartial i DeepReadonly

Możesz je połączyć, aby utworzyć głęboko częściowy i tylko do odczytu typ do bezpiecznego stosowania poprawek konfiguracji.

type SafePatch<T> = DeepReadonly<DeepPartial<T>>;

Kwestie wydajności

Typy rekurencyjne dla bardzo dużych obiektów mogą spowalniać sprawdzanie typów przez TypeScript. W kodzie, w którym wydajność ma kluczowe znaczenie, rozważ ograniczenie głębokości lub leniwą ewaluację.

// For very deep schemas, consider using Zod or io-ts
// which provide runtime + compile-time deep typing

Zastosowanie w praktyce: poprawki stanu React

DeepPartial doskonale nadaje się do funkcji stosujących poprawki stanu, które przyjmują tylko zmieniony fragment dużego obiektu stanu.

function patch<T>(state: T, changes: DeepPartial<T>): T {
  return { ...state, ...changes } as T;
}

Podsumowanie: głębokie typy narzędziowe

DeepPartial i DeepReadonly to rekurencyjne typy mapowane, które stosują swój modyfikator na każdym poziomie zagnieżdżonego obiektu. Tablice obsługuj osobno, a dla typów prostych stosuj przypadki bazowe.

Szybkie sprawdzenie

Jaki jest prawidłowy rekurencyjny przypadek bazowy dla DeepPartial?

Czego się Państwo nauczyli

Zaimplementowali Państwo DeepPartial i DeepReadonly za pomocą rekurencyjnych typów mapowanych. Tablice należy obsługiwać jako przypadek specjalny, a w przypadku bazowym zawsze zwracać typy proste bez zmian.

Często zadawane pytania

Czy lekcja „DeepPartial i DeepReadonly” jest bezpłatna?

Tak — pełny tekst „DeepPartial i DeepReadonly” 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 „DeepPartial i DeepReadonly”?

Buduj rekurencyjne wersje Partial i Readonly. Ć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 „DeepPartial i DeepReadonly”?

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