Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Typy union i intersection

9 min czytania ·
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 | number

Praktyczne 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 filtrami

Discriminated 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.

TypOperatorAnalogia w Parku JurajskimZastosowanie
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ówBezpieczna 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. 1. Co oznacza typ string | number w TypeScript?

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

  1. PytanieUnion types
  2. PytanieIntersection types
  3. Zadanie z kodemPraktyka: Union i Intersection types
  4. Ułóż w kolejnościSkładnia type alias
  5. Kliknij w kolejnościSortowanie: Definicja union type
  6. Ułóż w kolejnościZawężanie typu union

Przydatne artykuły