Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript
Typy narzędziowe TypeScript (Utility Types)
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 propertyW 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:
| Typ | Dział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. Który utility type w TypeScript sprawia, że WSZYSTKIE właściwości obiektu stają się opcjonalne?
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: