Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Typy narzędziowe TypeScript (Utility Types)

6 min czytania ·
W tej lekcji10

Dr. Henry Wu przegląda bazę danych genetycznych Parku Jurajskiego. "Mamy interfejs Dinosaur z 15 właściwościami," mówi, "ale do formularza aktualizacji potrzebuję tylko 5, a do podglądu zaledwie 3. Czy muszę tworzyć osobny interfejs dla każdego przypadku?" Kopiowanie interfejsów ma ukryty koszt: gdy do Dinosaur dojdzie nowe pole, każdą kopię trzeba poprawić ręcznie, a o jednej zawsze ktoś zapomni. Na szczęście TypeScript oferuje typy narzędziowe (Utility Types), czyli gotowe transformacje, które tworzą nowe typy na podstawie istniejących.

Czym są typy narzędziowe?

Typy narzędziowe to wbudowane w TypeScript typy generyczne, które przekształcają istniejące typy w nowe. Typ do przekształcenia podajesz w nawiasach ostrych, jak argument funkcji generycznej z poprzednich lekcji. Nie trzeba ich importować, a po kompilacji znikają, bo istnieją wyłącznie na etapie sprawdzania typów. Zamiast osobnych interfejsów masz jeden typ bazowy, z którego wyprowadzasz warianty, jak kolejne linie hodowlane z jednej próbki DNA.

Partial<T> - wszystkie właściwości opcjonalne

W przykładach użyjemy uproszczonego interfejsu z pięcioma polami. Pole dietType przyjmuje jedną z trzech wartości zapisanych jako unia literałów. Partial<T> sprawia, że wszystkie właściwości typu T stają się opcjonalne. To idealny typ dla aktualizacji, w której nie chcemy wymagać wszystkich pól:

interface Dinosaur {
  name: string;
  species: string;
  dangerLevel: number;
  enclosureId: string;
  dietType: 'herbivore' | 'carnivore' | 'omnivore';
}

// Partial<Dinosaur> = wszystkie pola opcjonalne
type DinosaurUpdate = Partial<Dinosaur>;

// Teraz możemy przekazać tylko zmienione pola
function updateDinosaur(id: string, changes: DinosaurUpdate): void {
  console.log(`Aktualizuję dinozaura ${id}:`, changes);
}

// Poprawne - przekazujemy tylko to, co zmieniamy
updateDinosaur('DINO-001', { dangerLevel: 9 });
updateDinosaur('DINO-002', { name: 'Blue', enclosureId: 'E-7' });

Sam interfejs Dinosaur się nie zmienił, bo Partial tworzy nowy typ obok niego. Kontrola nadal działa: literówka w rodzaju dangerLvl zostanie zgłoszona. Partial jest płytki, więc pola zagnieżdżonego obiektu pozostają wymagane.

Required<T> - wszystkie właściwości wymagane

Required<T> działa odwrotnie niż Partial: usuwa znak zapytania, więc wszystkie właściwości, nawet opcjonalne, stają się wymagane:

interface DinosaurConfig {
  name: string;
  trackingChip?: boolean;  // opcjonalne
  feedingSchedule?: string; // opcjonalne
}

// Required<DinosaurConfig> = wszystko wymagane
type CompleteDinosaurConfig = Required<DinosaurConfig>;

// Teraz trackingChip i feedingSchedule też są wymagane
const config: CompleteDinosaurConfig = {
  name: 'Rex',
  trackingChip: true,        // musi być podane
  feedingSchedule: '08:00'   // musi być podane
};

Gdyby zabrakło feedingSchedule, kompilator zgłosi brak właściwości. Przydaje się to wtedy, gdy konfiguracja po uzupełnieniu wartości domyślnych musi już być kompletna.

Pick<T, K> - wybierz właściwości

Pick<T, K> tworzy nowy typ zawierający tylko wybrane właściwości z T. Drugi parametr to nazwy pól połączone znakiem |:

// Tylko name i species z pełnego interfejsu Dinosaur
type DinosaurPreview = Pick<Dinosaur, 'name' | 'species'>;

// DinosaurPreview = { name: string; species: string; }

const preview: DinosaurPreview = {
  name: 'Blue',
  species: 'Velociraptor'
};

// Przydatne np. do listy wyświetlanej na ekranie
function renderDinosaurList(dinosaurs: DinosaurPreview[]): void {
  dinosaurs.forEach(dino => {
    console.log(`${dino.name} (${dino.species})`);
  });
}

Pick sprawdza, czy podane klucze istnieją: Pick<Dinosaur, 'enclosureID'> z literówką od razu skończy się błędem kompilacji. Typy pól przechodzą bez zmian, więc name nadal jest stringiem.

Omit<T, K> - pomiń właściwości

Omit<T, K> działa odwrotnie niż Pick i tworzy nowy typ bez wybranych właściwości:

// Dinosaur bez enclosureId (np. dla nowo odkrytego gatunku)
type DinosaurWithoutEnclosure = Omit<Dinosaur, 'enclosureId'>;

const newDiscovery: DinosaurWithoutEnclosure = {
  name: 'Nowy gatunek',
  species: 'Unknownus rex',
  dangerLevel: 5,
  dietType: 'carnivore'
  // nie musimy podawać enclosureId
};

// Omit wielu pól naraz
type DinosaurBasicInfo = Omit<Dinosaur, 'enclosureId' | 'dangerLevel'>;

Omit nie usuwa niczego z istniejących obiektów, tylko opisuje nowy kształt. Ma też pułapkę: w przeciwieństwie do Pick nie sprawdza, czy klucz istnieje, więc Omit<Dinosaur, 'enclosureID'> przejdzie bez błędu i nic nie pominie. Dlatego gdy zostawiasz tylko kilka pól, polecam Pick.

Record<K, V> - słownik typowany

Record<K, V> tworzy typ obiektu, w którym klucze mają typ K, a wartości typ V:

// Słownik: nazwa strefy -> lista dinozaurów
type ZoneMap = Record<string, Dinosaur[]>;

const parkZones: ZoneMap = {
  'Zone-A': [{ name: 'Rex', species: 'T-Rex', dangerLevel: 10, enclosureId: 'E-1', dietType: 'carnivore' }],
  'Zone-B': [{ name: 'Trike', species: 'Triceratops', dangerLevel: 3, enclosureId: 'E-2', dietType: 'herbivore' }]
};

// Record z ograniczonymi kluczami (union type)
type DietCount = Record<'herbivore' | 'carnivore' | 'omnivore', number>;

const census: DietCount = {
  herbivore: 45,
  carnivore: 12,
  omnivore: 8
};

Z kluczem string słownik przyjmie dowolną nazwę strefy. Z unią kluczy każdy z nich jest obowiązkowy, więc gdyby w spisie zabrakło omnivore, kompilator zgłosi błąd. To świetny sposób, by nie zapomnieć o żadnej kategorii.

Readonly<T> - niezmienialny typ

Readonly<T> sprawia, że wszystkie właściwości stają się tylko do odczytu:

type FrozenDinosaur = Readonly<Dinosaur>;

const frozenDNA: FrozenDinosaur = {
  name: 'Amber Specimen',
  species: 'Unknown',
  dangerLevel: 0,
  enclosureId: 'LAB-1',
  dietType: 'herbivore'
};

// frozenDNA.name = 'Changed'; // Błąd! Cannot assign to 'name' because it is a read-only property

W odróżnieniu od Object.freeze() z lekcji o prototypach ta ochrona działa tylko podczas kompilacji. W działającym JavaScript obiekt pozostaje zwykłym obiektem. Readonly jest też płytki i nie chroni obiektów zagnieżdżonych.

Łączenie typów narzędziowych

Prawdziwa moc pojawia się przy łączeniu kilku utility types. Takie zapisy czytaj od środka na zewnątrz:

// Formularz tworzenia dinozaura: wszystkie pola wymagane OPRÓCZ enclosureId
type CreateDinosaurForm = Omit<Dinosaur, 'enclosureId'> & {
  enclosureId?: string; // opcjonalne przy tworzeniu
};

// Formularz edycji: tylko wybrane pola, wszystkie opcjonalne
type EditDinosaurForm = Partial<Pick<Dinosaur, 'name' | 'dangerLevel' | 'enclosureId'>>;

// Niezmienialny podgląd z wybranymi polami
type DinosaurReadonlyPreview = Readonly<Pick<Dinosaur, 'name' | 'species' | 'dangerLevel'>>;

const readonlyPreview: DinosaurReadonlyPreview = {
  name: 'Blue',
  species: 'Velociraptor',
  dangerLevel: 8
};
// readonlyPreview.dangerLevel = 10; // Błąd!

EditDinosaurForm najpierw wybiera trzy pola, a potem czyni je opcjonalnymi. W CreateDinosaurForm znak & to intersekcja: łączy typ bez enclosureId z obiektem, w którym to pole jest opcjonalne.

Podsumowanie

Typy narzędziowe TypeScript pozwalają tworzyć warianty istniejących typów bez duplikacji kodu:

TypDziałanie
Partial<T>Wszystkie pola opcjonalne
Required<T>Wszystkie pola wymagane
Pick<T, K>Wybierz konkretne pola
Omit<T, K>Pomiń konkretne pola
Record<K, V>Słownik typowany
Readonly<T>Wszystkie pola tylko do odczytu

To nie cała skrzynka narzędzi: dokumentacja TypeScript opisuje też między innymi ReturnType, Parameters, Exclude i NonNullable. Jak mówi Dr. Wu: "Nie twórz 10 osobnych interfejsów, gdy jeden bazowy typ i utility types załatwią sprawę elegancko i bezpiecznie!" W następnej lekcji zajmiemy się konfiguracją TypeScript i narzędziami wokół kompilatora.

Praktyka

W piaskownicy czeka interfejs Dinosaur z przykładami Partial i Pick. Dopisz wariant z Omit i celowo zrób literówkę w kluczu, żeby zobaczyć różnicę między Pick a Omit.

Kod do tej lekcji: index.ts
// Typy narzędziowe TypeScript (Utility Types)
// System zarzadzania dinozaurami w Parku Jurajskim

// Bazowy interfejs dinozaura
interface Dinosaur {
  name: string;
  species: string;
  dangerLevel: number;
  enclosureId: string;
  dietType: "herbivore" | "carnivore" | "omnivore";
}

// === Partial<T> - wszystkie pola opcjonalne ===
type DinosaurUpdate = Partial<Dinosaur>;

function updateDinosaur(id: string, changes: DinosaurUpdate): void {
  console.log("Aktualizuje dinozaura " + id + ":", changes);
}

updateDinosaur("DINO-001", { dangerLevel: 9 });
updateDinosaur("DINO-002", { name: "Blue", enclosureId: "E-7" });

// === Pick<T, K> - wybierz wlasciwosci ===
type DinosaurPreview = Pick<Dinosaur, "name" | "species">;

const preview: DinosaurPreview = {
  name: "Blue",
  species: "Velociraptor",
};
console.log("\nPodglad:", preview);

// === Omit<T, K> - pomin wlasciwosci ===
type DinosaurWithoutEnclosure = Omit<Dinosaur, "enclosureId">;

const newDiscovery: DinosaurWithoutEnclosure = {
  name: "Nowy gatunek",
  species: "Unknownus rex",
  dangerLevel: 5,
  dietType: "carnivore",
};
console.log("\nNowe odkrycie:", newDiscovery);

// === Record<K, V> - slownik typowany ===
type DietCount = Record<"herbivore" | "carnivore" | "omnivore", number>;

const census: DietCount = {
  herbivore: 45,
  carnivore: 12,
  omnivore: 8,
};
console.log("\nSpis:", census);

// === Readonly<T> - niezmienialny typ ===
type FrozenDinosaur = Readonly<Dinosaur>;

const frozen: FrozenDinosaur = {
  name: "Amber Specimen",
  species: "Unknown",
  dangerLevel: 0,
  enclosureId: "LAB-1",
  dietType: "herbivore",
};
console.log("\nZamrozony:", frozen);
// frozen.name = "Changed"; // Blad! Read-only

// === Laczenie utility types ===
type EditForm = Partial<Pick<Dinosaur, "name" | "dangerLevel" | "enclosureId">>;

const edit: EditForm = { dangerLevel: 7 };
console.log("\nFormularz edycji:", edit);

Pamiętaj: typ bazowy to oryginalna próbka DNA, a typy narzędziowe hodują z niej odmiany, więc poprawka w próbce trafia do wszystkich linii naraz.

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Sprawdź się

Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.

  1. 1. Który utility type w TypeScript sprawia, że WSZYSTKIE właściwości obiektu stają się opcjonalne?

  2. 2. Co robi typ Omit<T, K> w TypeScript?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Użyj Pick, Omit i Partial na interfejsie Dinosaur do stworzenia wariantów typu.

  • Układanie w poziomie

    Ułóż elementy użycia utility type Pick:

  • Układanie w pionie

    Uporządkuj koncepty TypeScript od najprostszych do najbardziej złożonych:

  1. PytanieUtility type Partial
  2. PytanieTyp Omit
  3. Zadanie z kodemPraktyka: Utility types
  4. Ułóż w kolejnościSkładnia Pick
  5. PytanieTyp Pick
  6. Ułóż w kolejnościZłożoność typów TypeScript

Przydatne artykuły