Kurs JavaScript i TypeScript · Moduł 6: Podstawy TypeScript

Type aliases

12 min czytania ·
W tej lekcji10

Witaj ponownie w laboratorium genetycznym Parku Jurajskiego! Dr. Henry Wu dziś zapozna nas z niezwykle przydatnym mechanizmem TypeScript - aliasami typów (type aliases). Tak jak naukowcy w parku używają skrótowych nazw dla złożonych sekwencji genetycznych, tak programiści używają aliasów typów, aby uprościć złożone definicje typów.

Czym są aliasy typów (type aliases)?

Alias typu to po prostu nazwa, którą nadajemy istniejącemu typowi. Możemy aliasować zarówno proste, jak i złożone typy, co czyni kod bardziej czytelnym i łatwiejszym w utrzymaniu. To jak nazywanie różnych mieszanek DNA, aby łatwiej się do nich odwoływać podczas pracy laboratoryjnej.

Podstawowa składnia

Aliasy typów definiujemy za pomocą słowa kluczowego type:

// Prosty alias typu dla string
type IDGatunku = string;

// Używanie aliasu
const tRexID: IDGatunku = "TREX-01";
const velociraptorID: IDGatunku = "VELOC-01";

Aliasy dla typów prymitywnych

Aliasy typów mogą być stosowane do prostych typów, co może być pomocne dla dokumentacji i intencji kodu:

// Aliasy dla prostych typów
type PoziomBezpieczeństwa = number;
type NazwaGatunku = string;
type CzyDrapieżnik = boolean;

// Funkcja wykorzystująca aliasy typów
function ustawPoziomOgrodzenia(gatunek: NazwaGatunku, drapieżnik: CzyDrapieżnik): PoziomBezpieczeństwa {
  if (drapieżnik) {
    if (gatunek === "Tyrannosaurus") return 5;
    if (gatunek === "Velociraptor") return 4;
    return 3; // Inne drapieżniki
  } else {
    return 2; // Roślinożercy
  }
}

const poziomTRex = ustawPoziomOgrodzenia("Tyrannosaurus", true); // 5
console.log(`Poziom bezpieczeństwa dla T-Rex: ${poziomTRex}`);

Aliasy dla typów złożonych

Aliasy typów stają się szczególnie przydatne przy definiowaniu złożonych typów, takich jak obiekty, unie czy tablice:

// Alias dla typu obiektu (podobnie jak interfejs)
type Dinozaur = {
  id: string;
  nazwa: string;
  gatunek: string;
  wiek: number;
  waga: number;
  drapieżnik: boolean;
};

// Alias dla unii typów - różne identyfikatory
type IDDinozaura = string | number;

// Alias dla krotki (tuple) - współrzędne GPS z opisem
type Lokalizacja = [number, number, string];

// Alias dla tablicy
type ListaGatunków = string[];

// Alias dla literału obiektu z opcjonalnymi polami
type StatusZdrowia = {
  ogólnyStanZdrowia: "doskonały" | "dobry" | "średni" | "słaby" | "krytyczny";
  temperatura?: number;
  tętno?: number;
  priorytetLeczenia?: 1 | 2 | 3 | 4 | 5;
  notatki?: string;
};

// Tworzenie obiektów na podstawie aliasów typów
const rexLokalizacja: Lokalizacja = [35.6895, 139.6917, "Wybieg T-Rex, północne ogrodzenie"];
const gatunkiWParku: ListaGatunków = ["Tyrannosaurus", "Velociraptor", "Triceratops", "Brachiosaurus"];

const statusRex: StatusZdrowia = {
  ogólnyStanZdrowia: "dobry",
  temperatura: 38.2,
  priorytetLeczenia: 2,
  notatki: "Ostatnio nieco mniejszy apetyt"
};

// Funkcja pracująca na aliasie typu
function przygotujRaportDinozaura(dino: Dinozaur, status: StatusZdrowia, lokalizacja: Lokalizacja): string {
  const [lat, lng, opis] = lokalizacja;

  return `
    Raport o dinozaurze:
    ID: ${dino.id}
    Nazwa: ${dino.nazwa}
    Gatunek: ${dino.gatunek}
    Wiek: ${dino.wiek} lat
    Waga: ${dino.waga} kg
    Drapieżnik: ${dino.drapieżnik ? "Tak" : "Nie"}

    Status zdrowia: ${status.ogólnyStanZdrowia}
    ${status.temperatura ? `Temperatura: ${status.temperatura}°C` : ""}
    ${status.tętno ? `Tętno: ${status.tętno} uderzeń/min` : ""}

    Lokalizacja: ${opis} (${lat}, ${lng})
  `;
}

Aliasy z generycznymi typami

Aliasy typów mogą również być generyczne, co daje nam jeszcze większą elastyczność:

// Generyczny alias typu dla danych z systemów monitoringu
type DaneMonitoringu<T> = {
  czasPomiaru: Date;
  wartość: T;
  jednostka: string;
  prawidłowy: boolean;
};

// Używanie generycznego aliasu typu dla różnych rodzajów pomiarów
type PomiarTemperatury = DaneMonitoringu<number>;
type PomiarAktywności = DaneMonitoringu<"niska" | "średnia" | "wysoka">;
type PomiarPoziomuStresu = DaneMonitoringu<1 | 2 | 3 | 4 | 5>;

// Funkcja analizująca dane z monitoringu
function analizujDane<T>(dane: DaneMonitoringu<T>): void {
  console.log(`Pomiar z ${dane.czasPomiaru.toISOString()}`);
  console.log(`Wartość: ${dane.wartość} ${dane.jednostka}`);
  console.log(`Status: ${dane.prawidłowy ? "Prawidłowy" : "Wymaga uwagi"}`);
}

// Przykładowe użycie
const temperaturaWody: PomiarTemperatury = {
  czasPomiaru: new Date(),
  wartość: 24.5,
  jednostka: "°C",
  prawidłowy: true
};

const poziomAktywnościTRex: PomiarAktywności = {
  czasPomiaru: new Date(),
  wartość: "wysoka",
  jednostka: "poziom aktywności",
  prawidłowy: false // Wymaga uwagi, ponieważ T-Rex jest zbyt aktywny
};

analizujDane(temperaturaWody);
analizujDane(poziomAktywnościTRex);

Rekursywne aliasy typów

Aliasy typów mogą być rekursywne, co przydaje się przy modelowaniu struktur drzewiastych, takich jak hierarchie gatunków czy struktury organizacyjne parku:

// Rekursywny alias typu dla hierarchii kategorii dinozaurów
type KategoriaDinozaurów = {
  nazwa: string;
  opis?: string;
  podkategorie?: KategoriaDinozaurów[];
};

// Tworzenie hierarchii kategorii
const taksonomia: KategoriaDinozaurów = {
  nazwa: "Dinozaury",
  opis: "Główna klasyfikacja dinozaurów w Parku Jurajskim",
  podkategorie: [
    {
      nazwa: "Teropody",
      opis: "Mięsożerne, dwunożne dinozaury",
      podkategorie: [
        {
          nazwa: "Tyranozaury",
          podkategorie: [
            { nazwa: "Tyrannosaurus Rex" }
          ]
        },
        {
          nazwa: "Deinonychozaury",
          podkategorie: [
            { nazwa: "Velociraptor" },
            { nazwa: "Deinonychus" }
          ]
        }
      ]
    },
    {
      nazwa: "Zauropody",
      opis: "Duże, czworonożne roślinożercy o długiej szyi",
      podkategorie: [
        { nazwa: "Brachiosaurus" },
        { nazwa: "Diplodocus" }
      ]
    }
  ]
};

// Funkcja do renderowania drzewa taksonomii
function wyświetlTaksonomię(kategoria: KategoriaDinozaurów, poziom: number = 0): void {
  const wcięcie = "  ".repeat(poziom);
  console.log(`${wcięcie}${kategoria.nazwa}`);

  if (kategoria.opis) {
    console.log(`${wcięcie}  Opis: ${kategoria.opis}`);
  }

  if (kategoria.podkategorie && kategoria.podkategorie.length > 0) {
    kategoria.podkategorie.forEach(podkategoria => {
      wyświetlTaksonomię(podkategoria, poziom + 1);
    });
  }
}

wyświetlTaksonomię(taksonomia);

Aliasy typów vs. interfejsy

Aliasy typów są często porównywane z interfejsami, ponieważ w wielu przypadkach można ich używać zamiennie. Jednak istnieją między nimi pewne kluczowe różnice:

// Definicja struktury dinozaura używając interfejsu
interface DinozaurInterface {
  id: string;
  nazwa: string;
  gatunek: string;
}

// Równoważna definicja używając aliasu typu
type DinozaurType = {
  id: string;
  nazwa: string;
  gatunek: string;
};

// Obie działają podobnie przy podstawowym użyciu
const dino1: DinozaurInterface = { id: "001", nazwa: "Rex", gatunek: "Tyrannosaurus" };
const dino2: DinozaurType = { id: "002", nazwa: "Blue", gatunek: "Velociraptor" };

Główne różnice między aliasami typów a interfejsami

  1. Rozszerzalność:

    • Interfejsy mogą być rozszerzane przez deklarowanie ich wielokrotnie
    • Aliasy typów nie mogą być "otwarte" - raz zdefiniowany alias nie może być później rozszerzony
    // Interfejs można rozszerzać przez wielokrotną deklarację
    interface ZwierzęInterface {
      id: string;
      gatunek: string;
    }
    
    // Dodajemy nowe pola do istniejącego interfejsu
    interface ZwierzęInterface {
      wiek: number;
      waga: number;
    }
    
    // Teraz ZwierzęInterface ma wszystkie cztery pola
    const zwierzę: ZwierzęInterface = {
      id: "001",
      gatunek: "Tyrannosaurus",
      wiek: 7,
      waga: 7000
    };
    
    // Aliasu typu nie można rozszerzyć w ten sposób
    type ZwierzęType = {
      id: string;
      gatunek: string;
    }
    
    // To spowoduje błąd: Duplicate identifier 'ZwierzęType'
    // type ZwierzęType = {
    //   wiek: number;
    //   waga: number;
    // }
  2. Złożone typy:

    • Aliasy typów mogą reprezentować bezpośrednio unie, przecięcia i inne zaawansowane typy
    • Interfejsy są bardziej ukierunkowane na definiowanie kształtu obiektów
    // Możliwe tylko z aliasami typów
    type StatusBezpieczeństwa = "normalny" | "podwyższony" | "zagrożenie";
    type WspółrzędneGPS = [number, number];
    type IDZwierzęcia = string | number;
    
    // Z interfejsami byłoby to bardziej kłopotliwe
  3. Interfejsy dla klas:

    • Interfejsy są naturalnym wyborem do definiowania kontraktów, które klasy muszą implementować
    • Aliasy typów są bardziej elastyczne dla definiowania złożonych typów
    // Interfejs dla klasy
    interface SystemMonitoringu {
      uruchom(): void;
      zatrzymaj(): void;
      pobierzStatus(): string;
    }
    
    // Klasa implementująca interfejs
    class MonitoringWybiegów implements SystemMonitoringu {
      uruchom() { console.log("Uruchomiono monitoring wybiegów"); }
      zatrzymaj() { console.log("Zatrzymano monitoring wybiegów"); }
      pobierzStatus() { return "Aktywny"; }
    }

Łączenie aliasów typów z innymi funkcjami TypeScript

Aliasy typów mogą być łączone z innymi funkcjami TypeScript, tworząc potężne abstrakcje:

// Łączenie z typami union
type DaneDinozaura =
  | { typ: "podstawowe"; id: string; gatunek: string }
  | { typ: "rozszerzone"; id: string; gatunek: string; wiek: number; waga: number }
  | { typ: "pełne"; id: string; gatunek: string; wiek: number; waga: number; historia: string[]; statusZdrowia: string };

// Funkcja przetwarzająca różne poziomy danych
function przetwórzDaneDinozaura(dane: DaneDinozaura): void {
  console.log(`Przetwarzanie danych dla ID: ${dane.id}, gatunek: ${dane.gatunek}`);

  // Używamy discriminated union do określenia typu danych
  switch (dane.typ) {
    case "podstawowe":
      console.log("Przetwarzanie podstawowych danych");
      break;
    case "rozszerzone":
      console.log(`Wiek: ${dane.wiek}, Waga: ${dane.waga} kg`);
      break;
    case "pełne":
      console.log(`Wiek: ${dane.wiek}, Waga: ${dane.waga} kg`);
      console.log(`Historia: ${dane.historia.join(", ")}`);
      console.log(`Status zdrowia: ${dane.statusZdrowia}`);
      break;
  }
}

// Przykłady użycia
const podst: DaneDinozaura = {
  typ: "podstawowe",
  id: "TRX-001",
  gatunek: "Tyrannosaurus"
};

const rozszerz: DaneDinozaura = {
  typ: "rozszerzone",
  id: "VEL-001",
  gatunek: "Velociraptor",
  wiek: 4,
  waga: 150
};

const pełne: DaneDinozaura = {
  typ: "pełne",
  id: "TRI-001",
  gatunek: "Triceratops",
  wiek: 10,
  waga: 8000,
  historia: ["Narodziny: 2013", "Transfer z Lokacji B: 2016", "Złamane rogi: 2018", "Rekonwalescencja: 2019"],
  statusZdrowia: "Dobry"
};

przetwórzDaneDinozaura(podst);
przetwórzDaneDinozaura(rozszerz);
przetwórzDaneDinozaura(pełne);

Łączenie typów utility z aliasami typów

TypeScript oferuje wbudowane typy utility, które można łączyć z aliasami typów, co daje nam jeszcze większe możliwości modelowania danych:

// Podstawowy interfejs dla dinozaura
interface Dinozaur {
  id: string;
  nazwa: string;
  gatunek: string;
  wiek: number;
  waga: number;
  płeć: "samiec" | "samica";
  drapieżnik: boolean;
  aktywnyNocą: boolean;
  statusZdrowia: "doskonały" | "dobry" | "wymaga uwagi" | "chory" | "krytyczny";
}

// Aliasy typów z wykorzystaniem utility types

// Typ tylko do odczytu - użyteczny dla danych, które nie powinny być modyfikowane
type DinozaurTylkoDoOdczytu = Readonly<Dinozaur>;

// Typ z wybranymi polami - użyteczny dla częściowych danych
type DinozaurPodstawowy = Pick<Dinozaur, "id" | "nazwa" | "gatunek">;

// Typ z pominięciem niektórych pól - użyteczny gdy chcemy wykluczyć pewne dane
type DinozaurBezStatusu = Omit<Dinozaur, "statusZdrowia">;

// Typ z opcjonalnymi polami - przydatny do częściowych aktualizacji
type DinozaurCzęściowy = Partial<Dinozaur>;

// Typ z wymaganymi polami - wymuszanie, aby wszystkie pola były zdefiniowane
type DinozaurWymagane = Required<Dinozaur>;

// Typ mapujący rekordy - przydatny dla kolekcji indeksowanych kluczem
type BazaDanychDinozaurów = Record<string, Dinozaur>;

// Przykłady użycia
const rexDoOdczytu: DinozaurTylkoDoOdczytu = {
  id: "TRX-001",
  nazwa: "Rex",
  gatunek: "Tyrannosaurus",
  wiek: 7,
  waga: 7000,
  płeć: "samica",
  drapieżnik: true,
  aktywnyNocą: false,
  statusZdrowia: "dobry"
};

// rexDoOdczytu.wiek = 8; // Błąd: Cannot assign to 'wiek' because it is a read-only property

const rexPodstawowy: DinozaurPodstawowy = {
  id: "TRX-001",
  nazwa: "Rex",
  gatunek: "Tyrannosaurus"
};

// Częściowa aktualizacja danych
function aktualizujDaneDinozaura(id: string, dane: DinozaurCzęściowy): void {
  console.log(`Aktualizacja danych dla dinozaura ${id}`);
  console.log(dane);
  // W rzeczywistej aplikacji aktualizowalibyśmy dane w bazie
}

aktualizujDaneDinozaura("TRX-001", {
  wiek: 8,
  waga: 7200,
  statusZdrowia: "wymaga uwagi"
});

// Baza danych dinozaurów
const bazaDanych: BazaDanychDinozaurów = {
  "TRX-001": {
    id: "TRX-001",
    nazwa: "Rex",
    gatunek: "Tyrannosaurus",
    wiek: 7,
    waga: 7000,
    płeć: "samica",
    drapieżnik: true,
    aktywnyNocą: false,
    statusZdrowia: "dobry"
  },
  "VEL-001": {
    id: "VEL-001",
    nazwa: "Blue",
    gatunek: "Velociraptor",
    wiek: 4,
    waga: 150,
    płeć: "samica",
    drapieżnik: true,
    aktywnyNocą: true,
    statusZdrowia: "doskonały"
  }
};

console.log(`Liczba dinozaurów w bazie: ${Object.keys(bazaDanych).length}`);

Praktyczny przykład modelu danych Parku Jurajskiego

Zobaczmy teraz, jak możemy użyć aliasów typów wraz z innymi funkcjami TypeScript do stworzenia kompleksowego modelu danych dla systemu zarządzania Parkiem Jurajskim:

// Bazowe typy
type ID = string;
type Koordynaty = [number, number];
type PoziomDostępu = 1 | 2 | 3 | 4 | 5;
type StatusAktywności = "aktywny" | "nieaktywny" | "w trakcie konserwacji";
type StatusZdrowia = "doskonały" | "dobry" | "wymaga uwagi" | "chory" | "krytyczny";

// Typy dinozaurów
type GrupaTaksonomiczna = "teropody" | "zauropody" | "ceratopsy" | "stegozaury" | "ankylozaury";

type KlasaDiety = "roślinożerca" | "mięsożerca" | "wszystkożerca";

type DaneGatunku = {
  nazwa: string;
  grupaTaksonomiczna: GrupaTaksonomiczna;
  dieta: KlasaDiety;
  eraGeologiczna: string;
  średniaWaga: number;
  średniaDługość: number;
  średniWiek: number;
  zagrożenie: PoziomDostępu;
  opis: string;
};

type Okaz = {
  id: ID;
  gatunek: string;
  imię: string;
  wiek: number;
  waga: number;
  płeć: "samiec" | "samica";
  status: StatusZdrowia;
  lokalizacja: ID;
  dataPrzybycia: Date;
  historia: HistoriaMedyczna[];
};

type HistoriaMedyczna = {
  data: Date;
  typ: "badanie" | "leczenie" | "szczepienie" | "operacja";
  opis: string;
  weterynarz: ID;
};

// Typy pracowników
type Stanowisko =
  | "dyrektor"
  | "badacz"
  | "weterynarz"
  | "treser"
  | "bezpieczeństwo"
  | "obsługa"
  | "technik"
  | "przewodnik";

type Pracownik = {
  id: ID;
  imię: string;
  nazwisko: string;
  stanowisko: Stanowisko;
  poziomDostępu: PoziomDostępu;
  dataPrzyjęcia: Date;
  kontakt: {
    telefon: string;
    email: string;
    adres?: string;
  };
  obszarySpecjalizacji?: string[];
};

// Typy lokalizacji
type TypLokalizacji =
  | "wybieg"
  | "laboratorium"
  | "centrum operacyjne"
  | "strefa publiczna"
  | "gastronomia"
  | "sklep"
  | "atrakcja";

type SystemyBezpieczeństwa = {
  ogrodzenie: boolean;
  monitoringWideo: boolean;
  czujnikiRuchu: boolean;
  zasilanieZapasowe: boolean;
  napięcieElektryczne?: number; // tylko dla wybiegów drapieżników
};

type Lokalizacja = {
  id: ID;
  nazwa: string;
  typ: TypLokalizacji;
  współrzędne: Koordynaty;
  powierzchnia: number; // w hektarach
  pojemność: number; // maksymalna liczba osób/okazów
  wymaganyPoziomDostępu: PoziomDostępu;
  status: StatusAktywności;
  systemyBezpieczeństwa: SystemyBezpieczeństwa;
};

// Typy zdarzeń
type TypZdarzenia =
  | "ucieczkaDinozaura"
  | "awariaSystemu"
  | "wypadek"
  | "choroba"
  | "urodzenie"
  | "śmierć"
  | "transferOkazu"
  | "zagrożeniePogodowe";

type Zdarzenie = {
  id: ID;
  typ: TypZdarzenia;
  data: Date;
  lokalizacja: ID;
  uczestnicyDinozaury?: ID[];
  uczestnicyPracownicy?: ID[];
  opis: string;
  status: "w toku" | "rozwiązane" | "zamknięte";
  priorytet: 1 | 2 | 3 | 4 | 5;
  działaniaZapobiegawcze?: string[];
};

// System zarządzania parkiem
type SystemZarządzania = {
  dinozaury: Record<ID, Okaz>;
  gatunki: Record<string, DaneGatunku>;
  pracownicy: Record<ID, Pracownik>;
  lokalizacje: Record<ID, Lokalizacja>;
  zdarzenia: Record<ID, Zdarzenie>;

  // Metody systemu
  dodajOkaz: (okaz: Omit<Okaz, "id">) => ID;
  aktualizujStatusOkazu: (id: ID, status: StatusZdrowia) => void;
  przeniośOkaz: (id: ID, nowaLokalizacja: ID) => boolean;
  znajdźOkazy: (filtry: Partial<Okaz>) => Okaz[];
  generujRaportStanu: () => RaportStanu;
};

type RaportStanu = {
  liczbaOkazów: number;
  rozłożenieGatunków: Record<string, number>;
  statusyZdrowia: Record<StatusZdrowia, number>;
  obłożenieLokalizacji: Record<ID, { pojemność: number; aktualna: number }>;
  ostatnieZdarzenia: Zdarzenie[];
  alerty: string[];
};

// Symulacja części systemu
const systemParkuJurajskiego: Partial<SystemZarządzania> = {
  dinozaury: {},
  gatunki: {
    "Tyrannosaurus": {
      nazwa: "Tyrannosaurus Rex",
      grupaTaksonomiczna: "teropody",
      dieta: "mięsożerca",
      eraGeologiczna: "późna kreda",
      średniaWaga: 7000,
      średniaDługość: 12,
      średniWiek: 30,
      zagrożenie: 5,
      opis: "Jeden z największych drapieżników, jaki kiedykolwiek chodził po Ziemi."
    },
    "Velociraptor": {
      nazwa: "Velociraptor",
      grupaTaksonomiczna: "teropody",
      dieta: "mięsożerca",
      eraGeologiczna: "późna kreda",
      średniaWaga: 15,
      średniaDługość: 1.8,
      średniWiek: 25,
      zagrożenie: 4,
      opis: "Mały, szybki i inteligentny drapieżnik, polujący w grupach."
    }
  },
  lokalizacje: {
    "LOC-001": {
      id: "LOC-001",
      nazwa: "Padok T-Rex",
      typ: "wybieg",
      współrzędne: [20.1234, -75.8765],
      powierzchnia: 8,
      pojemność: 2,
      wymaganyPoziomDostępu: 4,
      status: "aktywny",
      systemyBezpieczeństwa: {
        ogrodzenie: true,
        monitoringWideo: true,
        czujnikiRuchu: true,
        zasilanieZapasowe: true,
        napięcieElektryczne: 10000
      }
    }
  }
};

// Funkcja demonstrująca użycie typów
function demonstrujSystemZarządzania() {
  console.log("System zarządzania Parkiem Jurajskim");
  console.log("----------------------------------");

  console.log("Dostępne gatunki:");
  Object.values(systemParkuJurajskiego.gatunki || {}).forEach(gatunek => {
    console.log(`- ${gatunek.nazwa} (${gatunek.dieta}, zagrożenie: ${gatunek.zagrożenie})`);
  });

  console.log("\nDostępne lokalizacje:");
  Object.values(systemParkuJurajskiego.lokalizacje || {}).forEach(lok => {
    console.log(`- ${lok.nazwa} (typ: ${lok.typ}, status: ${lok.status}, dostęp: poziom ${lok.wymaganyPoziomDostępu})`);
  });
}

demonstrujSystemZarządzania();

Podsumowanie

Aliasy typów w TypeScript są potężnym mechanizmem, który pozwala na tworzenie bardziej czytelnego, utrzymywalnego i bezpiecznego kodu. W kontekście zarządzania złożonym systemem, takim jak Park Jurajski, aliasy typów pozwalają na dokładne modelowanie danych i relacji między nimi.

Cecha aliasów typówZastosowanie w Parku Jurajskim
Podstawowe aliasyTypy identyfikatorów, poziomów bezpieczeństwa
Aliasy złożonych typówStruktury danych dinozaurów, pracowników, lokalizacji
Generyczne aliasySystem monitoringu różnych parametrów
Rekursywne typyHierarchie gatunków, struktura organizacyjna
Discriminated unionsRóżne poziomy danych, rodzaje zdarzeń
Utility typesZarządzanie modyfikowalnością i dostępnością danych

Dr. Wu podsumowuje: "Aliasy typów są jak nasze listy kontrolne i protokoły w laboratorium - pozwalają nam jasno określić, jak powinny wyglądać dane i operacje, jednocześnie czyniąc cały system bardziej zrozumiałym. W projekcie tak złożonym jak Park Jurajski, gdzie najmniejszy błąd może prowadzić do katastrofalnych konsekwencji, takie precyzyjne narzędzia są nieocenione."

Kod do tej lekcji: index.ts
// Type Aliases w Parku Jurajskim
console.log("Type Aliases TypeScript\n");

// ===========================================
// 1. Podstawowe type aliases
// ===========================================
console.log("=== PODSTAWOWE TYPE ALIASES ===");

// Alias dla prostych typów
type DinosaurID = string | number;
type Weight = number;
type Species = string;

let id1: DinosaurID = "DINO-001";
let id2: DinosaurID = 123;
let weight: Weight = 8000;
let species: Species = "Tyrannosaurus Rex";

console.log("ID:", id1, id2);
console.log("Weight:", weight);
console.log("Species:", species);

// ===========================================
// 2. Type vs Interface
// ===========================================
console.log("\n=== TYPE VS INTERFACE ===");

// Type alias
type DinosaurType = {
  name: string;
  species: string;
  age: number;
};

// Interface
interface DinosaurInterface {
  name: string;
  species: string;
  age: number;
}

const dino1: DinosaurType = {
  name: "Rex",
  species: "T-Rex",
  age: 5
};

const dino2: DinosaurInterface = {
  name: "Blue",
  species: "Velociraptor",
  age: 3
};

console.log("Type:", dino1);
console.log("Interface:", dino2);

// ===========================================
// 3. Union types z aliases
// ===========================================
console.log("\n=== UNION TYPES ===");

type Diet = "carnivore" | "herbivore" | "omnivore";
type Period = "Triassic" | "Jurassic" | "Cretaceous";
type SecurityLevel = "low" | "medium" | "high" | "critical";

type Dinosaur = {
  name: string;
  diet: Diet;
  period: Period;
  dangerLevel: SecurityLevel;
};

const trex: Dinosaur = {
  name: "Tyrannosaurus Rex",
  diet: "carnivore",
  period: "Cretaceous",
  dangerLevel: "critical"
};

console.log("T-Rex:", trex);

// ===========================================
// 4. Intersection types z aliases
// ===========================================
console.log("\n=== INTERSECTION TYPES ===");

type HasName = {
  name: string;
};

type HasWeight = {
  weight: number;
};

type HasDiet = {
  diet: Diet;
};

// Łączenie typów
type CompleteDinosaur = HasName & HasWeight & HasDiet & {
  species: string;
};

const velociraptor: CompleteDinosaur = {
  name: "Blue",
  weight: 350,
  diet: "carnivore",
  species: "Velociraptor"
};

console.log("Complete dinosaur:", velociraptor);

// ===========================================
// 5. Function types
// ===========================================
console.log("\n=== FUNCTION TYPES ===");

// Typ funkcji
type DinosaurFilter = (dino: Dinosaur) => boolean;
type DinosaurTransformer = (dino: Dinosaur) => string;
type DinosaurComparator = (a: Dinosaur, b: Dinosaur) => number;

const carnivoreFilter: DinosaurFilter = (dino) => dino.diet === "carnivore";
const nameTransformer: DinosaurTransformer = (dino) => `${dino.name}`;
const dangerComparator: DinosaurComparator = (a, b) => {
  const levels = { low: 1, medium: 2, high: 3, critical: 4 };
  return levels[b.dangerLevel] - levels[a.dangerLevel];
};

console.log("Is carnivore:", carnivoreFilter(trex));
console.log("Transformed:", nameTransformer(trex));

// ===========================================
// 6. Tuple types
// ===========================================
console.log("\n=== TUPLE TYPES ===");

type Coordinates = [latitude: number, longitude: number];
type DinosaurData = [name: string, weight: number, isCarnivore: boolean];
type RGB = [red: number, green: number, blue: number];

const paddockLocation: Coordinates = [22.3964, -159.5261];
const dinoInfo: DinosaurData = ["Rexy", 8000, true];
const warningColor: RGB = [255, 0, 0];

console.log("Location:", paddockLocation);
console.log("Dino info:", dinoInfo);
console.log("Warning color:", warningColor);

// ===========================================
// 7. Mapped types z aliases
// ===========================================
console.log("\n=== MAPPED TYPES ===");

type DinosaurStats = {
  health: number;
  hunger: number;
  energy: number;
  happiness: number;
};

// Wszystkie pola jako readonly
type ReadonlyStats = {
  readonly [K in keyof DinosaurStats]: DinosaurStats[K];
};

// Wszystkie pola jako opcjonalne
type PartialStats = {
  [K in keyof DinosaurStats]?: DinosaurStats[K];
};

const stats: DinosaurStats = {
  health: 100,
  hunger: 50,
  energy: 80,
  happiness: 90
};

const readonlyStats: ReadonlyStats = stats;
// readonlyStats.health = 90; // Error

const partialStats: PartialStats = {
  health: 100,
  energy: 80
  // pozostałe pola opcjonalne
};

console.log("Stats:", stats);
console.log("Partial stats:", partialStats);

// ===========================================
// 8. Conditional types
// ===========================================
console.log("\n=== CONDITIONAL TYPES ===");

// Conditional type
type IsCarnivore<T> = T extends { diet: "carnivore" } ? true : false;

type TRexIsCarnivore = IsCarnivore<typeof trex>; // true
type VelociraptorIsCarnivore = IsCarnivore<typeof velociraptor>; // true

// Extract - wyodrębnia typy spełniające warunek
type DinosaurSize = "small" | "medium" | "large" | "extra-large";
type LargeSizes = Extract<DinosaurSize, "large" | "extra-large">;

// Exclude - usuwa typy spełniające warunek
type SmallMediumSizes = Exclude<DinosaurSize, "large" | "extra-large">;

console.log("Conditional types defined");

// ===========================================
// 9. Utility types z aliases
// ===========================================
console.log("\n=== UTILITY TYPES ===");

type BaseDinosaur = {
  id: string;
  name: string;
  species: string;
  weight: number;
};

// Partial - wszystkie pola opcjonalne
type PartialDinosaur = Partial<BaseDinosaur>;

// Required - wszystkie pola wymagane
type RequiredDinosaur = Required<BaseDinosaur>;

// Pick - wybierz określone pola
type DinosaurSummary = Pick<BaseDinosaur, "name" | "species">;

// Omit - usuń określone pola
type PublicDinosaur = Omit<BaseDinosaur, "id">;

// Record - mapowanie kluczy do typu
type DinosaurCollection = Record<string, BaseDinosaur>;

const partialDino: PartialDinosaur = {
  name: "Rex"
  // wszystkie inne pola opcjonalne
};

const summary: DinosaurSummary = {
  name: "Rexy",
  species: "T-Rex"
};

const collection: DinosaurCollection = {
  "t-rex": {
    id: "001",
    name: "Rexy",
    species: "T-Rex",
    weight: 8000
  },
  "velociraptor": {
    id: "002",
    name: "Blue",
    species: "Velociraptor",
    weight: 350
  }
};

console.log("Partial:", partialDino);
console.log("Summary:", summary);
console.log("Collection:", collection);

// ===========================================
// 10. Podsumowanie
// ===========================================
console.log("\n=== PODSUMOWANIE ===");
console.log("Type Aliases - nazwy dla typów");
console.log("Union & Intersection - łączenie typów");
console.log("Function Types - typy funkcji");
console.log("Tuple Types - krotki");
console.log("Mapped Types - transformacja typów");
console.log("Conditional Types - warunkowe typy");
console.log("Utility Types - wbudowane narzędzia");

console.log("\nType Aliases 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 to jest type alias w TypeScript?

  2. 2. Co to jest type guard w TypeScript?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz type alias DinoStatus i funkcję z type guard sprawdzającą czy dinozaur jest mięsożerny.

  • Klikanie w kolejności

    Ułóż elementy type assertion w TypeScript:

  • Układanie w pionie

    Uporządkuj metody sprawdzania typów w TypeScript od najprostszych do najbardziej zaawansowanych:

  1. PytanieType alias w TypeScript
  2. PytanieType guards
  3. Zadanie z kodemPraktyka: Type aliases i type guards
  4. Kliknij w kolejnościSortowanie: Type assertion
  5. PytanieOperator as w TypeScript
  6. Ułóż w kolejnościMetody sprawdzania typów

Przydatne artykuły