Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript
Discriminated unions i pattern matching
W tej lekcji6
"W centrum kontroli Parku Jurajskiego każda sytuacja wymaga innej reakcji," wyjaśnia Claire Dearing, dyrektor operacyjna parku. "Ucieczka dinozaura, awaria zasilania, kontuzja gościa - każdy incydent ma swój protokół. Nie możemy pomylić jednego z drugim, bo konsekwencje byłyby katastrofalne. System musi sam rozpoznawać typ zdarzenia i kierować nas do właściwej procedury."
Discriminated unions (unie dyskryminowane) to potężny wzorzec TypeScript, w którym każdy wariant unii posiada wspólne pole - dyskryminator (tag) - jednoznacznie identyfikujące typ. W połączeniu z pattern matchingiem opartym o switch tworzą elegancki, bezpieczny i rozszerzalny system obsługi różnych stanów i zdarzeń.
Podstawy discriminated unions
Discriminated union to unia typów, w której każdy typ ma pole o tej samej nazwie (tag), ale z inną wartością literalną. TypeScript potrafi zawęzić typ na podstawie wartości tego pola.
// Pole "status" jest dyskryminatorem
interface ActiveDinosaur {
status: "active";
name: string;
enclosureId: string;
lastFed: Date;
}
interface SleepingDinosaur {
status: "sleeping";
name: string;
enclosureId: string;
sleepStarted: Date;
estimatedWakeUp: Date;
}
interface SickDinosaur {
status: "sick";
name: string;
enclosureId: string;
diagnosis: string;
veterinarianId: string;
}
type DinosaurState = ActiveDinosaur | SleepingDinosaur | SickDinosaur;
// TypeScript zawęża typ po sprawdzeniu pola status
function getDinosaurReport(dino: DinosaurState): string {
switch (dino.status) {
case "active":
// TypeScript wie, że to ActiveDinosaur - mamy dostęp do lastFed
return `${dino.name}: Aktywny, ostatnie karmienie: ${dino.lastFed.toLocaleString()}`;
case "sleeping":
// TypeScript wie, że to SleepingDinosaur - mamy dostęp do estimatedWakeUp
return `${dino.name}: Śpi, przewidywane przebudzenie: ${dino.estimatedWakeUp.toLocaleString()}`;
case "sick":
// TypeScript wie, że to SickDinosaur - mamy dostęp do diagnosis
return `${dino.name}: Chory - ${dino.diagnosis}, weterynarz: ${dino.veterinarianId}`;
}
}Kluczowe aspekty discriminated unions:
- Wspólne pole (tag/dyskryminator) musi mieć literalny typ (np.
"active", niestring) - Każdy wariant ma unikalną wartość tagu
- TypeScript automatycznie zawęża typ po sprawdzeniu wartości tagu
Pattern matching z switch
Konstrukcja switch to naturalne narzędzie do pattern matchingu w TypeScript. Każdy case odpowiada jednemu wariantowi discriminated union.
// System zdarzeń Parku Jurajskiego
interface FeedingEvent {
type: "feeding";
dinosaurId: string;
food: string;
amountKg: number;
timestamp: Date;
}
interface EscapeEvent {
type: "escape";
dinosaurId: string;
enclosureId: string;
breachType: "fence" | "gate" | "underground";
timestamp: Date;
}
interface MaintenanceEvent {
type: "maintenance";
systemId: string;
description: string;
priority: "low" | "medium" | "high" | "critical";
timestamp: Date;
}
interface VisitorEvent {
type: "visitor";
visitorCount: number;
zone: string;
eventKind: "entry" | "exit" | "emergency";
timestamp: Date;
}
type ParkEvent = FeedingEvent | EscapeEvent | MaintenanceEvent | VisitorEvent;
// Pattern matching - obsługa każdego typu zdarzenia
function processParkEvent(event: ParkEvent): { action: string; urgency: number } {
switch (event.type) {
case "feeding":
return {
action: `Karmienie ${event.dinosaurId}: ${event.amountKg}kg ${event.food}`,
urgency: 1
};
case "escape":
return {
action: `ALARM! ${event.dinosaurId} uciekł z ${event.enclosureId} (typ: ${event.breachType})`,
urgency: 10
};
case "maintenance":
const urgencyMap = { low: 2, medium: 4, high: 7, critical: 9 };
return {
action: `Konserwacja ${event.systemId}: ${event.description}`,
urgency: urgencyMap[event.priority]
};
case "visitor":
const visitorUrgency = event.eventKind === "emergency" ? 8 : 1;
return {
action: `Goście (${event.visitorCount}) w ${event.zone}: ${event.eventKind}`,
urgency: visitorUrgency
};
}
}Exhaustive handling - gwarancja obsługi wszystkich wariantów
Jedną z największych zalet discriminated unions jest możliwość exhaustive handling - kompilator może sprawdzić, czy obsłużyłeś WSZYSTKIE warianty. Jeśli dodasz nowy typ do unii, TypeScript natychmiast wskaże wszystkie miejsca, które wymagają aktualizacji.
// Helper do exhaustive check
function assertNever(value: never, message?: string): never {
throw new Error(message || `Nieobsłużony wariant: ${JSON.stringify(value)}`);
}
// Jeśli dodamy nowy typ zdarzenia do ParkEvent i zapomnimy go obsłużyć,
// TypeScript zgłosi błąd w klauzuli default
function processEventStrict(event: ParkEvent): string {
switch (event.type) {
case "feeding":
return "Karmienie";
case "escape":
return "Ucieczka";
case "maintenance":
return "Konserwacja";
case "visitor":
return "Goście";
default:
// Gdyby brakowało jednego case, TypeScript zgłosi błąd:
// "Type 'XXX' is not assignable to type 'never'"
return assertNever(event);
}
}Maszyny stanów z discriminated unions
Discriminated unions doskonale nadają się do modelowania maszyn stanów (state machines), gdzie obiekt może znajdować się w jednym z kilku stanów, a przejścia między stanami są ściśle kontrolowane.
// Stany zagrody dinozaurów jako maszyna stanów
interface EnclosureNormal {
state: "normal";
dinosaurCount: number;
securityLevel: number;
}
interface EnclosureLockdown {
state: "lockdown";
dinosaurCount: number;
securityLevel: number;
reason: string;
lockdownSince: Date;
}
interface EnclosureBreach {
state: "breach";
dinosaurCount: number;
escapedCount: number;
breachLocation: string;
responseTeamDispatched: boolean;
}
interface EnclosureMaintenance {
state: "maintenance";
dinosaurCount: 0; // Zagroda musi być pusta podczas konserwacji
scheduledEnd: Date;
maintenanceType: string;
}
type EnclosureState = EnclosureNormal | EnclosureLockdown | EnclosureBreach | EnclosureMaintenance;
// Dozwolone przejścia między stanami
function transitionEnclosure(
current: EnclosureState,
action: "lockdown" | "breach" | "repair" | "resolve"
): EnclosureState {
switch (current.state) {
case "normal":
if (action === "lockdown") {
return {
state: "lockdown",
dinosaurCount: current.dinosaurCount,
securityLevel: current.securityLevel + 5,
reason: "Procedura bezpieczeństwa",
lockdownSince: new Date()
};
}
if (action === "repair") {
if (current.dinosaurCount > 0) {
throw new Error("Nie można rozpocząć konserwacji - zagroda zajęta!");
}
return {
state: "maintenance",
dinosaurCount: 0,
scheduledEnd: new Date(Date.now() + 86400000),
maintenanceType: "Standardowy przegląd"
};
}
return current;
case "lockdown":
if (action === "breach") {
return {
state: "breach",
dinosaurCount: current.dinosaurCount - 1,
escapedCount: 1,
breachLocation: "Sektor nieznany",
responseTeamDispatched: false
};
}
if (action === "resolve") {
return {
state: "normal",
dinosaurCount: current.dinosaurCount,
securityLevel: current.securityLevel
};
}
return current;
case "breach":
if (action === "resolve") {
return {
state: "lockdown",
dinosaurCount: current.dinosaurCount + current.escapedCount,
securityLevel: 10,
reason: "Post-breach lockdown",
lockdownSince: new Date()
};
}
return current;
case "maintenance":
if (action === "resolve") {
return {
state: "normal",
dinosaurCount: 0,
securityLevel: 5
};
}
return current;
}
}
// Test maszyny stanów
let enclosure: EnclosureState = {
state: "normal",
dinosaurCount: 3,
securityLevel: 5
};
console.log("Stan początkowy:", enclosure.state);
enclosure = transitionEnclosure(enclosure, "lockdown");
console.log("Po lockdown:", enclosure.state);
enclosure = transitionEnclosure(enclosure, "breach");
console.log("Po breach:", enclosure.state);
if (enclosure.state === "breach") {
console.log("Uciekło dinozaurów:", enclosure.escapedCount);
}Odpowiedzi API jako discriminated unions
Częstym zastosowaniem w prawdziwych aplikacjach jest modelowanie odpowiedzi API za pomocą discriminated unions:
// Generyczny typ odpowiedzi API
interface SuccessResponse<T> {
status: "success";
data: T;
timestamp: Date;
}
interface ErrorResponse {
status: "error";
errorCode: number;
message: string;
timestamp: Date;
}
interface LoadingResponse {
status: "loading";
progress: number; // 0-100
}
type ApiResponse<T> = SuccessResponse<T> | ErrorResponse | LoadingResponse;
// Typ danych dinozaura z API
interface DinosaurApiData {
id: string;
name: string;
species: string;
weight: number;
}
// Obsługa odpowiedzi z pełnym bezpieczeństwem typów
function renderDinosaurData(response: ApiResponse<DinosaurApiData>): string {
switch (response.status) {
case "loading":
return `Ładowanie... ${response.progress}%`;
case "error":
return `Błąd ${response.errorCode}: ${response.message}`;
case "success":
const { name, species, weight } = response.data;
return `${name} (${species}) - ${weight} kg`;
}
}
// Testowe odpowiedzi
const loading: ApiResponse<DinosaurApiData> = { status: "loading", progress: 45 };
const success: ApiResponse<DinosaurApiData> = {
status: "success",
data: { id: "D-001", name: "Rexy", species: "T-Rex", weight: 8000 },
timestamp: new Date()
};
const error: ApiResponse<DinosaurApiData> = {
status: "error",
errorCode: 404,
message: "Dinozaur nie znaleziony",
timestamp: new Date()
};
console.log(renderDinosaurData(loading));
console.log(renderDinosaurData(success));
console.log(renderDinosaurData(error));Podsumowanie
Discriminated unions i pattern matching to jedne z najpotężniejszych wzorców w TypeScript:
- Discriminated unions - każdy wariant ma wspólne pole (tag) z unikalną literalną wartością
- Pattern matching z switch - elegancka obsługa wszystkich wariantów
- Exhaustive handling z never - kompilator pilnuje, że obsłużyłeś każdy wariant
- Maszyny stanów - modelowanie dozwolonych przejść między stanami
- Odpowiedzi API - typowanie success/error/loading z pełnym bezpieczeństwem
Jak mówi Claire Dearing: "W Parku Jurajskim każdy scenariusz ma swój protokół. Z discriminated unions TypeScript pilnuje, że żaden scenariusz nie zostanie pominięty. To jak system wczesnego ostrzegania - nie pozwala na przeoczenie żadnego zagrożenia."
Kod do tej lekcji: index.ts
// Discriminated unions i pattern matching - Park Jurajski
console.log("=== DISCRIMINATED UNIONS ===\n");
// ===========================================
// 1. Podstawowy discriminated union
// ===========================================
interface ActiveDino {
status: "active";
name: string;
lastFed: string;
}
interface SleepingDino {
status: "sleeping";
name: string;
wakeUpAt: string;
}
interface SickDino {
status: "sick";
name: string;
diagnosis: string;
}
type DinoState = ActiveDino | SleepingDino | SickDino;
function getReport(dino: DinoState): string {
switch (dino.status) {
case "active": return `${dino.name}: aktywny, karmiony ${dino.lastFed}`;
case "sleeping": return `${dino.name}: spi, obudzi sie ${dino.wakeUpAt}`;
case "sick": return `${dino.name}: chory - ${dino.diagnosis}`;
}
}
console.log("--- Stan dinozaurow ---");
console.log(getReport({ status: "active", name: "Rexy", lastFed: "10:00" }));
console.log(getReport({ status: "sleeping", name: "Blue", wakeUpAt: "15:00" }));
console.log(getReport({ status: "sick", name: "Cera", diagnosis: "Goraczka" }));
// ===========================================
// 2. System zdarzen z pattern matching
// ===========================================
interface FeedEvent { type: "feed"; dinoId: string; food: string; kg: number; }
interface EscapeEvent { type: "escape"; dinoId: string; zone: string; }
interface MaintenanceEvent { type: "maintenance"; system: string; priority: "low" | "high"; }
type ParkEvent = FeedEvent | EscapeEvent | MaintenanceEvent;
function processEvent(event: ParkEvent): { action: string; urgency: number } {
switch (event.type) {
case "feed":
return { action: `Karmienie ${event.dinoId}: ${event.kg}kg ${event.food}`, urgency: 1 };
case "escape":
return { action: `ALARM! ${event.dinoId} uciekl z ${event.zone}!`, urgency: 10 };
case "maintenance":
return { action: `Konserwacja: ${event.system}`, urgency: event.priority === "high" ? 7 : 3 };
}
}
console.log("\n--- Zdarzenia ---");
const events: ParkEvent[] = [
{ type: "feed", dinoId: "D-01", food: "Koza", kg: 50 },
{ type: "escape", dinoId: "D-03", zone: "Sektor B" },
{ type: "maintenance", system: "Ogrodzenie A", priority: "high" },
];
events.forEach(e => {
const r = processEvent(e);
console.log(`[${r.urgency}] ${r.action}`);
});
// ===========================================
// 3. Exhaustive check z never
// ===========================================
function assertNever(value: never, msg?: string): never {
throw new Error(msg || "Nieobsluzony wariant: " + JSON.stringify(value));
}
function strictProcess(event: ParkEvent): string {
switch (event.type) {
case "feed": return "Karmienie";
case "escape": return "Ucieczka";
case "maintenance": return "Konserwacja";
default: return assertNever(event);
}
}
console.log("\n--- Exhaustive check ---");
console.log("Wszystkie warianty obslugzone:", strictProcess(events[0]));
// ===========================================
// 4. Maszyna stanow zagrody
// ===========================================
interface NormalState { state: "normal"; dinoCount: number; }
interface LockdownState { state: "lockdown"; dinoCount: number; reason: string; }
interface BreachState { state: "breach"; escaped: number; }
type EncState = NormalState | LockdownState | BreachState;
function transition(current: EncState, action: "lock" | "breach" | "resolve"): EncState {
switch (current.state) {
case "normal":
if (action === "lock") return { state: "lockdown", dinoCount: current.dinoCount, reason: "Procedura" };
return current;
case "lockdown":
if (action === "breach") return { state: "breach", escaped: 1 };
if (action === "resolve") return { state: "normal", dinoCount: current.dinoCount };
return current;
case "breach":
if (action === "resolve") return { state: "lockdown", dinoCount: 0, reason: "Post-breach" };
return current;
}
}
console.log("\n--- Maszyna stanow ---");
let enc: EncState = { state: "normal", dinoCount: 3 };
console.log("Start:", enc.state);
enc = transition(enc, "lock");
console.log("Po lock:", enc.state);
enc = transition(enc, "breach");
console.log("Po breach:", enc.state);
enc = transition(enc, "resolve");
console.log("Po resolve:", enc.state);
// ===========================================
// 5. API Response pattern
// ===========================================
interface Success<T> { status: "ok"; data: T; }
interface Err { status: "error"; code: number; message: string; }
interface Loading { status: "loading"; progress: number; }
type ApiResponse<T> = Success<T> | Err | Loading;
function render(res: ApiResponse<{ name: string }>): string {
switch (res.status) {
case "loading": return `Ladowanie... ${res.progress}%`;
case "error": return `Blad ${res.code}: ${res.message}`;
case "ok": return `Dane: ${res.data.name}`;
}
}
console.log("\n--- API Response ---");
console.log(render({ status: "loading", progress: 50 }));
console.log(render({ status: "ok", data: { name: "Rexy" } }));
console.log(render({ status: "error", code: 404, message: "Nie znaleziono" }));
console.log("\nDiscriminated unions = bezpieczne pattern matching!");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 to jest discriminated union w TypeScript?
2. Do czego służy typ never w klauzuli default switch'a przy obsłudze discriminated union?
To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy typu discriminated union:
- Edytor kodu
Stwórz discriminated union z pattern matchingiem i exhaustive check dla zdarzeń parku
- Układanie w poziomie
Ułóż elementy użycia Omit:
- Układanie w poziomie
Ułóż elementy użycia Record:
- Edytor kodu
Stwórz kompletny system typów dla zarządzania parkiem
- Układanie w poziomie
Ułóż elementy użycia Required:
- Układanie w poziomie
Ułóż elementy Pick type:
- Układanie w pionie
Uporządkuj ewolucję od prostego typu do zaawansowanego utility type:
Zadania po tej lekcji
- PytanieDiscriminated union
- Ułóż w kolejnościSkładnia discriminated union
- Zadanie z kodemDiscriminated unions - praktyka
- PytanieExhaustive check z never
- PytaniePraktyczne użycie Omit
- Ułóż w kolejnościSkładnia Omit
- PytanieCo robi Record<K, T>
- Ułóż w kolejnościSkładnia Record
- Zadanie z kodemZaawansowany system typów - praktyka
- Ułóż w kolejnościSkładnia Required
- Ułóż w kolejnościSkładnia Pick
- Ułóż w kolejnościOd typu do generycznego utility