Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript

Discriminated unions i pattern matching

7 min czytania ·
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:

  1. Wspólne pole (tag/dyskryminator) musi mieć literalny typ (np. "active", nie string)
  2. Każdy wariant ma unikalną wartość tagu
  3. 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:

  1. Discriminated unions - każdy wariant ma wspólne pole (tag) z unikalną literalną wartością
  2. Pattern matching z switch - elegancka obsługa wszystkich wariantów
  3. Exhaustive handling z never - kompilator pilnuje, że obsłużyłeś każdy wariant
  4. Maszyny stanów - modelowanie dozwolonych przejść między stanami
  5. 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. 1. Co to jest discriminated union w TypeScript?

  2. 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:

  1. PytanieDiscriminated union
  2. Ułóż w kolejnościSkładnia discriminated union
  3. Zadanie z kodemDiscriminated unions - praktyka
  4. PytanieExhaustive check z never
  5. PytaniePraktyczne użycie Omit
  6. Ułóż w kolejnościSkładnia Omit
  7. PytanieCo robi Record<K, T>
  8. Ułóż w kolejnościSkładnia Record
  9. Zadanie z kodemZaawansowany system typów - praktyka
  10. Ułóż w kolejnościSkładnia Required
  11. Ułóż w kolejnościSkładnia Pick
  12. Ułóż w kolejnościOd typu do generycznego utility

Przydatne artykuły