Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript
Typy union i intersection
W tej lekcji4
Witaj w zaawansowanym laboratorium typów TypeScript w Parku Jurajskim! Dr. Henry Wu jest dziś szczególnie podekscytowany, ponieważ będziemy omawiać dwa potężne mechanizmy TypeScript, które można porównać do jego najbardziej ambitnych projektów inżynierii genetycznej: typy union (unii) i intersection (przecięcia).
Union Types - czyli "albo to, albo to"
Typ union (unii) pozwala zmiennej przyjmować wartości jednego z kilku różnych typów. To trochę jak wybieg hybrydowy w parku, który może pomieścić różne gatunki dinozaurów, ale tylko jeden rodzaj na raz.
Podstawowa składnia typów union
Typ union tworzymy za pomocą operatora | (pionowa kreska):
// Zmienna może być typu string LUB number
let identyfikatorDinozaura: string | number;
identyfikatorDinozaura = "TREX-01"; // Ok, string jest dozwolony
identyfikatorDinozaura = 12345; // Ok, number jest dozwolony
// identyfikatorDinozaura = true; // Błąd! boolean nie jest częścią unii string | numberPraktyczne zastosowania typów union
Typy union są niezwykle przydatne w wielu praktycznych scenariuszach w Parku Jurajskim:
1. Obsługa różnych formatów identyfikatorów
// Funkcja, która może przyjąć różne typy identyfikatorów
function znajdźDinozaura(id: string | number): void {
// Musimy sprawdzić typ, zanim wykonamy operacje specyficzne dla danego typu
if (typeof id === "string") {
console.log(`Szukam dinozaura o kodzie: ${id.toUpperCase()}`);
} else {
console.log(`Szukam dinozaura o numerze: ${id.toFixed(0)}`);
}
}
znajdźDinozaura("RAPTOR-BLUE"); // "Szukam dinozaura o kodzie: RAPTOR-BLUE"
znajdźDinozaura(42); // "Szukam dinozaura o numerze: 42"2. Funkcje zwracające różne typy
// Funkcja, która może zwrócić dinozaura lub komunikat o błędzie
function pobierzDaneDinozaura(id: string):
{ nazwa: string; gatunek: string; wiek: number } | string {
// Symulacja bazy danych
const bazaDanych = new Map([
["TRex1", { nazwa: "Rex", gatunek: "Tyrannosaurus", wiek: 7 }],
["Rap1", { nazwa: "Blue", gatunek: "Velociraptor", wiek: 4 }]
]);
const dinozaur = bazaDanych.get(id);
if (dinozaur) {
return dinozaur; // Zwraca obiekt dinozaura
} else {
return `Nie znaleziono dinozaura o ID: ${id}`; // Zwraca komunikat błędu
}
}
const wynik = pobierzDaneDinozaura("TRex1");
// Musimy sprawdzić typ zwróconej wartości
if (typeof wynik === "string") {
console.log(`Błąd: ${wynik}`);
} else {
console.log(`Znaleziono: ${wynik.nazwa}, gatunek: ${wynik.gatunek}`);
}3. Obsługa opcjonalnych parametrów
// Funkcja tworząca raport, która może przyjąć różne parametry filtrowania
function generujRaportDinozaurów(
filtr?: { gatunek?: string; minWiek?: number; drapieżniki?: boolean }
): string {
let raport = "Raport dinozaurów:\n";
if (filtr) {
raport += "Filtry:";
if (filtr.gatunek) raport += ` Gatunek=${filtr.gatunek}`;
if (filtr.minWiek) raport += ` MinWiek=${filtr.minWiek}`;
if (filtr.drapieżniki !== undefined) raport += ` TylkoDrapieżniki=${filtr.drapieżniki}`;
} else {
raport += "Brak filtrów - pokazuję wszystkie dinozaury";
}
return raport;
}
console.log(generujRaportDinozaurów()); // Bez filtrów
console.log(generujRaportDinozaurów({ gatunek: "Velociraptor" })); // Z filtrem gatunku
console.log(generujRaportDinozaurów({ minWiek: 5, drapieżniki: true })); // Z wieloma filtramiDiscriminated Unions (Unie dyskryminacyjne)
Unie dyskryminacyjne to zaawansowana technika używania typów union z "właściwością dyskryminującą", która pozwala TypeScriptowi rozpoznać, z którym typem mamy do czynienia. To jak system identyfikacji dinozaurów w parku, który pozwala natychmiast rozpoznać, czy mamy do czynienia z roślinożercą czy drapieżnikiem.
// Definiowanie interfejsów z właściwością dyskryminującą "typ"
interface Roślinożerca {
typ: "roślinożerca";
dieta: string[];
poziomAgresji: number; // 1-10
}
interface Drapieżnik {
typ: "drapieżnik";
ofiary: string[];
siłaUgryzienia: number; // w PSI
}
// Typ będący unią dwóch interfejsów
type Dinozaur = Roślinożerca | Drapieżnik;
// Funkcja korzystająca z unii dyskryminacyjnej
function zarządzajDinozaurem(dino: Dinozaur): void {
// Sprawdzamy właściwość dyskryminującą
switch (dino.typ) {
case "roślinożerca":
// TypeScript wie, że tutaj dino jest typu Roślinożerca
console.log(`Przygotuj paszę: ${dino.dieta.join(", ")}`);
if (dino.poziomAgresji > 7) {
console.log("Uwaga: Roślinożerca z wysokim poziomem agresji!");
}
break;
case "drapieżnik":
// TypeScript wie, że tutaj dino jest typu Drapieżnik
console.log(`Przygotuj mięso dla: ${dino.ofiary.join(", ")}`);
if (dino.siłaUgryzienia > 10000) {
console.log("Uwaga: Bardzo niebezpieczny drapieżnik!");
}
break;
}
}
// Przykłady użycia
const triceratops: Roślinożerca = {
typ: "roślinożerca",
dieta: ["paprocie", "cykady", "iglaste"],
poziomAgresji: 6
};
const tRex: Drapieżnik = {
typ: "drapieżnik",
ofiary: ["triceratops", "edmontosaurus", "pachycephalosaurus"],
siłaUgryzienia: 12800
};
zarządzajDinozaurem(triceratops);
zarządzajDinozaurem(tRex);Intersection Types - czyli "to i to"
Typ intersection (przecięcia) pozwala na połączenie wielu typów w jeden, bardziej złożony typ. To jak eksperymenty Dr. Wu z łączeniem DNA różnych dinozaurów, by stworzyć zupełnie nowe gatunki o cechach wszystkich "składników".
Podstawowa składnia typów intersection
Typ intersection tworzymy za pomocą operatora &:
// Definiowanie interfejsów podstawowych cech
interface PodstawowyDinozaur {
id: number;
nazwa: string;
gatunek: string;
wiek: number;
}
interface CechyFizyczne {
wysokość: number; // w metrach
długość: number; // w metrach
waga: number; // w kilogramach
}
interface CechyBehawioralne {
poziomAgresji: number; // 1-10
terytorialny: boolean;
społeczny: boolean;
}
// Tworzenie typu będącego przecięciem trzech interfejsów
type PełnyProfilDinozaura = PodstawowyDinozaur & CechyFizyczne & CechyBehawioralne;
// Teraz obiekt musi implementować wszystkie właściwości ze wszystkich trzech interfejsów
const velociraptor: PełnyProfilDinozaura = {
// Z PodstawowyDinozaur
id: 101,
nazwa: "Blue",
gatunek: "Velociraptor",
wiek: 4,
// Z CechyFizyczne
wysokość: 0.5,
długość: 2,
waga: 15,
// Z CechyBehawioralne
poziomAgresji: 8,
terytorialny: true,
społeczny: true
};Praktyczne zastosowania typów intersection
Typy intersection są szczególnie przydatne w budowaniu złożonych systemów w Parku Jurajskim:
1. Kompozycja zachowań
// Definiowanie różnych umiejętności
interface Pływający {
prędkośćPływania: number; // km/h
maksGłębokość: number; // metry
wytrzymałośćPodWodą: number; // minuty
}
interface Latający {
rozpiętośćSkrzydeł: number; // metry
prędkośćLotu: number; // km/h
maksWysokość: number; // metry
}
// Dinozaur, który potrafi i pływać, i latać (jak Pteranodon)
type LatającyIPływającyDinozaur = PodstawowyDinozaur & Latający & Pływający;
const pteranodon: LatającyIPływającyDinozaur = {
id: 201,
nazwa: "Pterri",
gatunek: "Pteranodon",
wiek: 12,
// Umiejętności latania
rozpiętośćSkrzydeł: 8,
prędkośćLotu: 90,
maksWysokość: 500,
// Umiejętności pływania
prędkośćPływania: 20,
maksGłębokość: 10,
wytrzymałośćPodWodą: 3
};2. Rozszerzanie istniejących typów
// Podstawowy interfejs bezpieczeństwa dla wszystkich wybiegów
interface PodstawowySystemBezpieczeństwa {
podwójneOgrodzenie: boolean;
monitoringWideo: boolean;
czujnikiRuchu: boolean;
}
// Dodatkowe środki bezpieczeństwa dla drapieżników
interface ZabezpieczeniaDlaDrapieżników {
napięcieElektryczne: number; // wolty
grubośćŚcian: number; // cm
kopułaZabezpieczająca: boolean;
}
// Pełny system bezpieczeństwa dla wybiegu drapieżników
type WybiegDrapieżnika = PodstawowySystemBezpieczeństwa & ZabezpieczeniaDlaDrapieżników;
// Używamy intersection do dodania informacji o paddle
type WybiegTRex = WybiegDrapieżnika & {
obszar: number; // hektary
ukształtowanieTerenu: string[];
roślinnośćWiarygodna: boolean;
};
const wybiegRex: WybiegTRex = {
// PodstawowySystemBezpieczeństwa
podwójneOgrodzenie: true,
monitoringWideo: true,
czujnikiRuchu: true,
// ZabezpieczeniaDlaDrapieżników
napięcieElektryczne: 10000,
grubośćŚcian: 50,
kopułaZabezpieczająca: false,
// Specyficzne dla WybiegTRex
obszar: 8,
ukształtowanieTerenu: ["wysoka trawa", "wzgórza", "strumień"],
roślinnośćWiarygodna: true
};3. Łączenie funkcjonalności w złożonych systemach
// Interfejs systemu obserwacji
interface SystemObserwacji {
kamery: number;
rozdzielczość: string;
śledzeniePodczerwienią: boolean;
rozpocznijNagrywanie(): void;
zatrzymajNagrywanie(): void;
}
// Interfejs systemu alarmowego
interface SystemAlarmowy {
sygnałDźwiękowy: boolean;
sygnałŚwietlny: boolean;
powiadomienieSMS: boolean;
uruchomAlarm(poziom: number): void;
wyłączAlarm(): void;
}
// Złożony system bezpieczeństwa łączący obie funkcjonalności
type SystemBezpieczeństwaParku = SystemObserwacji & SystemAlarmowy;
// Implementacja systemu bezpieczeństwa
class PełnySystemBezpieczeństwa implements SystemBezpieczeństwaParku {
// SystemObserwacji
kamery: number = 24;
rozdzielczość: string = "4K";
śledzeniePodczerwienią: boolean = true;
rozpocznijNagrywanie(): void {
console.log("Rozpoczynam nagrywanie ze wszystkich kamer");
}
zatrzymajNagrywanie(): void {
console.log("Zatrzymuję nagrywanie");
}
// SystemAlarmowy
sygnałDźwiękowy: boolean = true;
sygnałŚwietlny: boolean = true;
powiadomienieSMS: boolean = true;
uruchomAlarm(poziom: number): void {
console.log(`Uruchamiam alarm poziomu ${poziom}!`);
if (this.sygnałDźwiękowy) console.log("Syreny włączone");
if (this.sygnałŚwietlny) console.log("Światła ostrzegawcze włączone");
if (this.powiadomienieSMS) console.log("Wysyłam powiadomienia SMS do personelu");
}
wyłączAlarm(): void {
console.log("Wyłączam wszystkie systemy alarmowe");
}
// Dodatkowe metody specyficzne dla pełnego systemu
uruchomProcedurębezpieczeństwa(kodZagrożenia: string): void {
console.log(`Inicjuję procedurę bezpieczeństwa: ${kodZagrożenia}`);
this.rozpocznijNagrywanie();
this.uruchomAlarm(kodZagrożenia === "CZERWONY" ? 3 : 1);
}
}
// Użycie systemu
const systemBezpieczeństwa = new PełnySystemBezpieczeństwa();
systemBezpieczeństwa.uruchomProcedurębezpieczeństwa("CZERWONY");Połączenie union i intersection - zaawansowane przypadki
Prawdziwa potęga TypeScript ujawnia się, gdy łączymy typy union i intersection w bardziej złożone struktury - podobnie jak Dr. Wu łączy DNA różnych gatunków, aby stworzyć zupełnie nowe dinozaury.
// Podstawowe typy dinozaurów
interface Dinozaur {
id: number;
nazwa: string;
gatunek: string;
}
interface LądowyDinozaur {
środowisko: "lądowe";
prędkośćBiegu: number; // km/h
}
interface WodnyDinozaur {
środowisko: "wodne";
prędkośćPływania: number; // km/h
maksGłębokość: number; // metry
}
interface PowietrznyDinozaur {
środowisko: "powietrzne";
prędkośćLotu: number; // km/h
maksWysokość: number; // metry
}
// Typy dla różnych zdolności
interface ZdolnościŁowieckie {
siłaUgryzienia: number; // PSI
strategiaPolowania: "zasadzka" | "pościg" | "stadna";
}
interface ZdolnościObronneRoślinożercy {
pancerz: boolean;
rogi: boolean;
kolce: boolean;
siłaObronna: number; // 1-10
}
// Złożony typ wykorzystujący union i intersection
type DinozaurParkowy = Dinozaur &
(
(LądowyDinozaur & ZdolnościŁowieckie) |
(LądowyDinozaur & ZdolnościObronneRoślinożercy) |
(WodnyDinozaur & ZdolnościŁowieckie) |
(PowietrznyDinozaur & ZdolnościŁowieckie)
);
// Przykłady użycia
const tyranozaur: DinozaurParkowy = {
id: 1,
nazwa: "Rex",
gatunek: "Tyrannosaurus Rex",
środowisko: "lądowe",
prędkośćBiegu: 30,
siłaUgryzienia: 12800,
strategiaPolowania: "pościg"
};
const stegozaur: DinozaurParkowy = {
id: 2,
nazwa: "Spike",
gatunek: "Stegosaurus",
środowisko: "lądowe",
prędkośćBiegu: 7,
pancerz: true,
rogi: false,
kolce: true,
siłaObronna: 8
};
// Funkcja obsługująca złożone typy
function analizujDinozaura(dino: DinozaurParkowy): void {
console.log(`Analizuję: ${dino.nazwa} (${dino.gatunek})`);
// Sprawdzamy środowisko
if (dino.środowisko === "lądowe") {
console.log(`Prędkość biegu: ${dino.prędkośćBiegu} km/h`);
// Sprawdzamy, czy to drapieżnik czy roślinożerca
if ("siłaUgryzienia" in dino) {
console.log(`Drapieżnik - siła ugryzienia: ${dino.siłaUgryzienia} PSI`);
console.log(`Strategia polowania: ${dino.strategiaPolowania}`);
} else if ("siłaObronna" in dino) {
console.log("Roślinożerca z mechanizmami obronnymi:");
if (dino.pancerz) console.log("- Wyposażony w pancerz");
if (dino.rogi) console.log("- Posiada rogi");
if (dino.kolce) console.log("- Posiada kolce");
console.log(`Siła obronna: ${dino.siłaObronna}/10`);
}
} else if (dino.środowisko === "wodne") {
console.log(`Wodny drapieżnik - prędkość pływania: ${dino.prędkośćPływania} km/h`);
console.log(`Maksymalna głębokość: ${dino.maksGłębokość} m`);
} else if (dino.środowisko === "powietrzne") {
console.log(`Powietrzny drapieżnik - prędkość lotu: ${dino.prędkośćLotu} km/h`);
console.log(`Maksymalna wysokość lotu: ${dino.maksWysokość} m`);
}
}
analizujDinozaura(tyranozaur);
console.log("---");
analizujDinozaura(stegozaur);Podsumowanie
Typy union i intersection są jak zaawansowane techniki inżynierii genetycznej Dr. Wu - dają nam niezwykłą moc i elastyczność w projektowaniu złożonych systemów TypeScript.
| Typ | Operator | Analogia w Parku Jurajskim | Zastosowanie | |
|---|---|---|---|---|
| Union | ` | ` | Wybieg mogący pomieścić różne dinozaury (ale tylko jeden rodzaj jednocześnie) | Zmienne, które mogą mieć różne typy |
| Discriminated Union | ` | ` z właściwością dyskryminującą | System identyfikacji różnych gatunków dinozaurów | Bezpieczna obsługa różnych wariantów typu |
| Intersection | & | Łączenie DNA z różnych dinozaurów | Łączenie interfejsów/typów w bardziej złożone struktury |
Dr. Wu podsumowuje dzisiejszą lekcję: "TypeScript, podobnie jak nasze laboratorium genetyczne, daje nam ogromne możliwości. Dzięki union i intersection types możemy tworzyć systemy dokładnie dopasowane do naszych potrzeb, łącząc proste elementy w złożone struktury. Jednak pamiętaj - z wielką mocą przychodzi wielka odpowiedzialność. Użyj tej wiedzy mądrze, aby stworzyć bezpieczny i niezawodny park."
Kod do tej lekcji: index.ts
// Typy union i intersection w Parku Jurajskim
console.log("Union i Intersection Types\n");
// ===========================================
// 1. UNION TYPES - typ A lub B
// ===========================================
console.log("=== UNION TYPES ===");
// Prosty union type
type DinosaurDiet = "carnivore" | "herbivore" | "omnivore";
let trexDiet: DinosaurDiet = "carnivore";
let brachiosaurDiet: DinosaurDiet = "herbivore";
console.log("T-Rex diet:", trexDiet);
console.log("Brachiosaurus diet:", brachiosaurDiet);
// Union z różnymi typami
type ID = number | string;
let paddockId: ID = "P-01";
let dinosaurId: ID = 123;
console.log("Paddock ID:", paddockId);
console.log("Dinosaur ID:", dinosaurId);
// Union z obiektami
interface Carnivore {
type: "carnivore";
huntingStyle: string;
preySize: string;
}
interface Herbivore {
type: "herbivore";
plantPreference: string;
grazingHours: number;
}
type Dinosaur = Carnivore | Herbivore;
const trex: Carnivore = {
type: "carnivore",
huntingStyle: "ambush predator",
preySize: "large"
};
const triceratops: Herbivore = {
type: "herbivore",
plantPreference: "ferns and cycads",
grazingHours: 16
};
// Type guards dla union types
function describeDiet(dino: Dinosaur): string {
if (dino.type === "carnivore") {
return `Carnivore: ${dino.huntingStyle}, preys on ${dino.preySize} animals`;
} else {
return `Herbivore: prefers ${dino.plantPreference}, grazes ${dino.grazingHours}h/day`;
}
}
console.log("\nT-Rex:", describeDiet(trex));
console.log("Triceratops:", describeDiet(triceratops));
// ===========================================
// 2. INTERSECTION TYPES - typ A i B
// ===========================================
console.log("\n=== INTERSECTION TYPES ===");
// Łączenie typów
interface HasName {
name: string;
}
interface HasWeight {
weight: number;
}
interface HasDiet {
diet: DinosaurDiet;
}
// Intersection - musi mieć wszystkie właściwości
type CompleteDinosaur = HasName & HasWeight & HasDiet;
const velociraptor: CompleteDinosaur = {
name: "Blue",
weight: 350,
diet: "carnivore"
};
console.log("Complete dinosaur:", velociraptor);
// Rozszerzanie interfejsów przez intersection
interface BasicInfo {
id: number;
species: string;
}
interface LocationInfo {
paddockId: string;
zone: string;
}
interface HealthInfo {
isHealthy: boolean;
lastCheckup: Date;
}
type FullDinosaurInfo = BasicInfo & LocationInfo & HealthInfo;
const rexy: FullDinosaurInfo = {
id: 1,
species: "Tyrannosaurus Rex",
paddockId: "P-01",
zone: "Carnivore Zone",
isHealthy: true,
lastCheckup: new Date()
};
console.log("\nFull info:", rexy);
// ===========================================
// 3. Łączenie Union i Intersection
// ===========================================
console.log("\n=== UNION + INTERSECTION ===");
interface Swimmer {
swimSpeed: number;
}
interface Runner {
runSpeed: number;
}
interface Flyer {
flySpeed: number;
}
// Dinozaur może pływać LUB latać, ALE musi umieć biegać
type ActiveDinosaur = Runner & (Swimmer | Flyer);
const mosasaurus: ActiveDinosaur = {
runSpeed: 5, // na lądzie powolny
swimSpeed: 50 // w wodzie szybki
};
const pteranodon: ActiveDinosaur = {
runSpeed: 10,
flySpeed: 80
};
console.log("Mosasaurus:", mosasaurus);
console.log("Pteranodon:", pteranodon);
// ===========================================
// 4. Praktyczne zastosowania
// ===========================================
console.log("\n=== PRAKTYCZNE ZASTOSOWANIA ===");
// API Response type
type SuccessResponse = {
status: "success";
data: any;
};
type ErrorResponse = {
status: "error";
message: string;
code: number;
};
type ApiResponse = SuccessResponse | ErrorResponse;
function handleResponse(response: ApiResponse): void {
if (response.status === "success") {
console.log("Data received:", response.data);
} else {
console.log(`Error ${response.code}: ${response.message}`);
}
}
const success: ApiResponse = {
status: "success",
data: { dinosaurs: [trex, triceratops] }
};
const error: ApiResponse = {
status: "error",
message: "Paddock breach detected",
code: 503
};
handleResponse(success);
handleResponse(error);
// Event types
interface BaseEvent {
timestamp: Date;
source: string;
}
interface FeedingEvent extends BaseEvent {
type: "feeding";
dinosaurId: number;
foodAmount: number;
}
interface EscapeEvent extends BaseEvent {
type: "escape";
dinosaurId: number;
paddockId: string;
severity: "low" | "high";
}
interface MaintenanceEvent extends BaseEvent {
type: "maintenance";
paddockId: string;
duration: number;
}
type ParkEvent = FeedingEvent | EscapeEvent | MaintenanceEvent;
function logEvent(event: ParkEvent): void {
console.log(`[${event.timestamp.toISOString()}] ${event.source}`);
switch (event.type) {
case "feeding":
console.log(` Feeding dinosaur #${event.dinosaurId}: ${event.foodAmount}kg`);
break;
case "escape":
console.log(` ESCAPE from paddock ${event.paddockId}! Severity: ${event.severity}`);
break;
case "maintenance":
console.log(` Maintenance on paddock ${event.paddockId}: ${event.duration}h`);
break;
}
}
const feedingEvent: FeedingEvent = {
type: "feeding",
timestamp: new Date(),
source: "Automated System",
dinosaurId: 1,
foodAmount: 400
};
const escapeEvent: EscapeEvent = {
type: "escape",
timestamp: new Date(),
source: "Security Alert",
dinosaurId: 1,
paddockId: "P-01",
severity: "high"
};
console.log("\nEvent log:");
logEvent(feedingEvent);
logEvent(escapeEvent);
// ===========================================
// 5. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("Union Types (|) - wartość może być jednym z typów");
console.log("Intersection Types (&) - wartość musi spełniać wszystkie typy");
console.log("Type Guards - sprawdzanie typu w runtime");
console.log("Discriminated Unions - rozróżnianie po polu");
console.log("\nUnion i Intersection Types opanowane!");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. Co oznacza typ string | number w TypeScript?
2. Co robi typ A & B (intersection type)?
Zadania praktyczne w grze
- Edytor kodu
Stwórz typ union DietType = 'herbivore' | 'carnivore' | 'omnivore' i intersection type AquaticDino = Dinosaur & SwimmingAbility.
- Układanie w poziomie
Ułóż elementy type alias:
- Klikanie w kolejności
Ułóż elementy definicji union type:
- Układanie w pionie
Uporządkuj kroki zawężania (narrowing) typu union w TypeScript: