Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript

Dekoratory klas

12 min czytania ·
W tej lekcji9

"W Parku Jurajskim każdy budynek i infrastruktura muszą być odpowiednio oznaczone i zabezpieczone," wyjaśnia John Hammond, spacerując po nowo wybudowanym Centrum Gości. "Niektóre obszary są dostępne dla wszystkich, inne tylko dla personelu z odpowiednimi uprawnieniami, a jeszcze inne wymagają specjalnych protokołów bezpieczeństwa. Bez odpowiedniego systemu oznaczeń i zabezpieczeń, byłby chaos."

W TypeScripcie, podobnie jak w Parku Jurajskim, potrzebujemy sposobu na oznaczanie i modyfikowanie klas bez ingerencji w ich wewnętrzną implementację. Dekoratory klas są jak specjalne oznaczenia i protokoły bezpieczeństwa, które możemy nałożyć na klasy, aby dodać im dodatkowe funkcjonalności lub cechy.

Wprowadzenie do dekoratorów klas

Dekoratory klas pozwalają na modyfikowanie lub rozszerzanie klas w sposób deklaratywny. Są one szczególnie przydatne, gdy chcemy:

  1. Dodać metadane do klasy
  2. Automatycznie zarejestrować klasę w rejestrze
  3. Dodać metody lub właściwości do klasy
  4. Zmienić zachowanie konstruktora
  5. Zastosować wzorce projektowe jak Singleton lub Factory

Dekorator klasy to po prostu funkcja, która przyjmuje konstruktor klasy jako argument i może go zmodyfikować, rozszerzyć lub całkowicie zastąpić.

Uwaga o wersjach: przykłady w tej i dwóch kolejnych lekcjach używają starszego trybu dekoratorów, który włącza opcja "experimentalDecorators": true w tsconfig.json. Z tego trybu korzystają m.in. NestJS i TypeORM. Od TypeScriptu 5.0 bez tej opcji działają standardowe dekoratory ECMAScript, które dostają dwa argumenty: dekorowaną wartość i obiekt context.

Podstawowa składnia dekoratora klasy

Dekoratory klas umieszczamy nad definicją klasy, poprzedzając je symbolem @ :

@dekorator
class MojaKlasa {
  // implementacja klasy
}

Gdzie dekorator to funkcja:

function dekorator(target: Function) {
  // Modyfikacja lub rozszerzenie klasy
}

Przykład: System monitorowania w Parku Jurajskim

Zacznijmy od prostego dekoratora klasy, który będzie oznaczał obiekty wymagające monitorowania w Parku Jurajskim:

// Dekorator klasy
function Monitorowany(target: Function) {
  // Dodaj właściwość do prototypu klasy
  target.prototype.monitorowany = true;

  // Dodaj metodę do prototypu klasy
  target.prototype.rozpocznijMonitoring = function() {
    console.log(`Rozpoczęto monitoring: ${this.nazwa || this.constructor.name}`);
  };
}

// Użycie dekoratora
@Monitorowany
class ZagrodaDinozaurow {
  nazwa: string;

  constructor(nazwa: string) {
    this.nazwa = nazwa;
  }

  dodajDinozaura(dinozaur: string) {
    console.log(`Dodano ${dinozaur} do zagrody ${this.nazwa}`);
  }
}

// Użycie klasy z dekoratorem
const zagrodaRaptorów = new ZagrodaDinozaurow("Velociraptor");
zagrodaRaptorów.dodajDinozaura("Blue");

// Teraz możemy używać właściwości i metod dodanych przez dekorator
if ((zagrodaRaptorów as any).monitorowany) {
  (zagrodaRaptorów as any).rozpocznijMonitoring();
}

W tym przykładzie, dekorator Monitorowany dodaje właściwość monitorowany i metodę rozpocznijMonitoring do prototypu klasy ZagrodaDinozaurow. Dzięki temu, wszystkie instancje tej klasy będą miały dostęp do tych dodatkowych funkcjonalności.

Dekoratory klas z parametrami

Możemy również tworzyć dekoratory, które przyjmują parametry. W takim przypadku, nasza funkcja dekoratora musi zwrócić inną funkcję, która będzie właściwym dekoratorem:

// Dekorator fabryka
function PoziomBezpieczenstwa(poziom: number) {
  // Zwracamy właściwy dekorator klasy
  return function(target: Function) {
    // Dodajemy właściwość do klasy (nie do prototypu)
    target.prototype.poziomBezpieczenstwa = poziom;

    // Dodajemy metodę weryfikującą dostęp
    target.prototype.sprawdzDostep = function(poziomPracownika: number): boolean {
      return poziomPracownika >= poziom;
    };

    // Możemy też nadpisać konstruktor
    const oryginalnyKonstruktor = target;

    // Funkcja zastępująca konstruktor
    function nowyKonstruktor(...args: any[]) {
      console.log(`Tworzenie obiektu z poziomem bezpieczeństwa: ${poziom}`);

      // Wywołanie oryginalnego konstruktora
      const instancja = new (oryginalnyKonstruktor as any)(...args);

      // Można dodać dodatkową logikę
      if (poziom >= 4) {
        console.log("UWAGA: Tworzenie obiektu o wysokim poziomie bezpieczeństwa!");
      }

      return instancja;
    }

    // Kopiujemy właściwości prototypu
    nowyKonstruktor.prototype = oryginalnyKonstruktor.prototype;

    // Zwracamy nowy konstruktor
    return nowyKonstruktor as any;
  };
}

// Użycie dekoratora z parametrem
@PoziomBezpieczenstwa(4)
class LaboratoriumGenetyczne {
  nazwa: string;

  constructor(nazwa: string) {
    this.nazwa = nazwa;
    console.log(`Utworzono laboratorium: ${nazwa}`);
  }

  klonujDinozaura(gatunek: string) {
    console.log(`Klonowanie ${gatunek} w laboratorium ${this.nazwa}`);
  }
}

// Użycie klasy z dekoratorem
const laboratorium = new LaboratoriumGenetyczne("Hammond Lab");

// Sprawdzanie poziomu bezpieczeństwa
console.log(`Poziom bezpieczeństwa: ${(laboratorium as any).poziomBezpieczenstwa}`);

// Weryfikacja dostępu
const poziomPracownika = 3;
if ((laboratorium as any).sprawdzDostep(poziomPracownika)) {
  console.log("Dostęp przyznany do laboratorium");
  laboratorium.klonujDinozaura("Velociraptor");
} else {
  console.log("Dostęp zabroniony! Wymagany wyższy poziom bezpieczeństwa.");
}

W tym przykładzie, dekorator PoziomBezpieczenstwa przyjmuje parametr określający wymagany poziom dostępu. Dodaje on właściwość poziomBezpieczenstwa i metodę sprawdzDostep do klasy, a także nadpisuje konstruktor, aby dodać dodatkowe logowanie.

Łączenie wielu dekoratorów

Możemy zastosować wiele dekoratorów do jednej klasy. W takim przypadku, dekoratory są stosowane od dołu do góry (od ostatniego do pierwszego):

// Dekorator rejestrujący w systemie
function Rejestrowany(target: Function) {
  console.log(`Rejestracja klasy: ${target.name}`);
  (target as any).zarejestrowany = true;
}

// Dekorator dodający logowanie
function Logowany(prefiks: string) {
  return function(target: Function) {
    // Zapisujemy oryginalne metody
    const oryginalneMetody: Record<string, Function> = {};

    // Iterujemy po metodach prototypu
    for (const propertyName of Object.getOwnPropertyNames(target.prototype)) {
      const descriptor = Object.getOwnPropertyDescriptor(target.prototype, propertyName);

      // Sprawdzamy, czy to metoda i czy nie jest konstruktorem
      if (descriptor && typeof descriptor.value === 'function' && propertyName !== 'constructor') {
        oryginalneMetody[propertyName] = descriptor.value;

        // Nadpisujemy metodę, dodając logowanie
        Object.defineProperty(target.prototype, propertyName, {
          value: function(...args: any[]) {
            console.log(`${prefiks}: Wywołanie ${propertyName} z argumentami: ${JSON.stringify(args)}`);
            const rezultat = oryginalneMetody[propertyName].apply(this, args);
            console.log(`${prefiks}: ${propertyName} zwróciło: ${JSON.stringify(rezultat)}`);
            return rezultat;
          }
        });
      }
    }
  };
}

// Użycie wielu dekoratorów
@Rejestrowany
@PoziomBezpieczenstwa(3)
@Logowany("[System kontroli]")
class SystemKontroliBram {
  stan: "otwarte" | "zamknięte" = "zamknięte";

  constructor() {
    console.log("Inicjalizacja systemu kontroli bram.");
  }

  otwórzBramy(): boolean {
    console.log("Otwieranie bram parku...");
    this.stan = "otwarte";
    return true;
  }

  zamknijBramy(): boolean {
    console.log("Zamykanie bram parku...");
    this.stan = "zamknięte";
    return true;
  }

  sprawdźStan(): string {
    return `Bramy są ${this.stan}`;
  }
}

// Użycie klasy z wieloma dekoratorami
const kontrolaBram = new SystemKontroliBram();
kontrolaBram.otwórzBramy();
console.log(kontrolaBram.sprawdźStan());
kontrolaBram.zamknijBramy();

W tym przykładzie, klasa SystemKontroliBram ma zastosowane trzy dekoratory:

  1. @Rejestrowany - rejestruje klasę w systemie
  2. @PoziomBezpieczenstwa(3) - ustawia poziom bezpieczeństwa 3
  3. @Logowany("[System kontroli]") - dodaje logowanie do wszystkich metod klasy

Praktyczny przykład: System zarządzania parkiem

Poniżej przedstawiamy bardziej rozbudowany przykład systemu zarządzania Parkiem Jurajskim, wykorzystujący różne dekoratory klas:

// Podstawowy interfejs dla wszystkich zasobów parku
interface ZasobParku {
  id: string;
  nazwa: string;
  lokalizacja: string;
  status: "aktywny" | "nieaktywny" | "w konserwacji" | "awaria";
}

// Rejestr zasobów parku
class RejestrZasobów {
  private static rejestr: Map<string, ZasobParku[]> = new Map();

  static rejestrujZasób(typ: string, zasób: ZasobParku): void {
    if (!this.rejestr.has(typ)) {
      this.rejestr.set(typ, []);
    }

    this.rejestr.get(typ)!.push(zasób);
    console.log(`Zarejestrowano zasób: ${zasób.nazwa} (${typ})`);
  }

  static pobierzZasoby(typ: string): ZasobParku[] {
    return this.rejestr.get(typ) || [];
  }

  static pobierzWszystkieZasoby(): Map<string, ZasobParku[]> {
    return new Map(this.rejestr);
  }
}

// Dekorator do rejestracji zasobów
function RejestrujZasób(typ: string) {
  return function<T extends { new(...args: any[]): ZasobParku }>(konstruktor: T) {
    return class extends konstruktor {
      constructor(...args: any[]) {
        super(...args);
        RejestrZasobów.rejestrujZasób(typ, this);
      }
    };
  };
}

// Dekorator do wymuszania audytu
function WymagaAudytu(częstotliwośćDni: number) {
  return function(target: Function) {
    target.prototype.ostatniAudyt = new Date();
    target.prototype.częstotliwośćAudytu = częstotliwośćDni;

    target.prototype.wymagaAudytu = function(): boolean {
      const teraz = new Date();
      const różnicaCzasu = teraz.getTime() - this.ostatniAudyt.getTime();
      const różnicaDni = różnicaCzasu / (1000 * 3600 * 24);

      return różnicaDni >= this.częstotliwośćAudytu;
    };

    target.prototype.przeprowadźAudyt = function(): void {
      console.log(`Przeprowadzono audyt dla: ${this.nazwa}`);
      this.ostatniAudyt = new Date();
    };
  };
}

// Dekorator dodający śledzenie historii statusu
function ŚledźStatusy(target: Function) {
  // Dodaj tablicę historii statusów
  target.prototype.historiaStatusów = [];

  // Zapisz oryginalną metodę ustawiania statusu
  const oryginalnySetStatus = Object.getOwnPropertyDescriptor(
    target.prototype, 'status'
  )?.set;

  // Nadpisz setter dla statusu
  if (oryginalnySetStatus) {
    Object.defineProperty(target.prototype, 'status', {
      set: function(nowyStatus: "aktywny" | "nieaktywny" | "w konserwacji" | "awaria") {
        const staryCzas = new Date();
        const staryStatus = this._status;

        // Wywołaj oryginalny setter
        oryginalnySetStatus.call(this, nowyStatus);

        // Zapisz zmianę w historii
        this.historiaStatusów.push({
          czasZmiany: staryCzas,
          z: staryStatus,
          na: nowyStatus
        });

        console.log(`Zmieniono status ${this.nazwa}: ${staryStatus || 'brak'} -> ${nowyStatus}`);
      },
      get: Object.getOwnPropertyDescriptor(target.prototype, 'status')?.get
    });
  }
}

// Dekorator Singleton
function Singleton<T extends { new(...args: any[]): any }>(konstruktor: T) {
  // Zapisz oryginalny konstruktor
  const oryginalnyKonstruktor = konstruktor;

  // Zastąp konstruktor funkcją, która kontroluje tworzenie instancji
  const nowyKonstruktor: any = function(...args: any[]) {
    if (!nowyKonstruktor.instancja) {
      nowyKonstruktor.instancja = new oryginalnyKonstruktor(...args);
    } else {
      console.warn(`Singleton ${konstruktor.name} już istnieje. Zwracanie istniejącej instancji.`);
    }

    return nowyKonstruktor.instancja;
  };

  // Skopiuj prototyp
  nowyKonstruktor.prototype = oryginalnyKonstruktor.prototype;

  // Przechowaj oryginalny konstruktor
  nowyKonstruktor.oryginalnyKonstruktor = oryginalnyKonstruktor;

  return nowyKonstruktor;
}

// Implementacja różnych zasobów parku

@RejestrujZasób("zagroda")
@WymagaAudytu(7) // Audyt co 7 dni
@ŚledźStatusy
class ZagrodaDinozaurów implements ZasobParku {
  id: string;
  nazwa: string;
  lokalizacja: string;
  private _status: "aktywny" | "nieaktywny" | "w konserwacji" | "awaria" = "aktywny";

  // Właściwości specyficzne dla zagrody
  rodzajDinozaurów: string;
  pojemność: number;
  aktualnaLiczba: number;

  constructor(
    id: string,
    nazwa: string,
    lokalizacja: string,
    rodzajDinozaurów: string,
    pojemność: number
  ) {
    this.id = id;
    this.nazwa = nazwa;
    this.lokalizacja = lokalizacja;
    this.rodzajDinozaurów = rodzajDinozaurów;
    this.pojemność = pojemność;
    this.aktualnaLiczba = 0;
  }

  get status(): "aktywny" | "nieaktywny" | "w konserwacji" | "awaria" {
    return this._status;
  }

  set status(nowyStatus: "aktywny" | "nieaktywny" | "w konserwacji" | "awaria") {
    this._status = nowyStatus;
  }

  dodajDinozaura(): boolean {
    if (this.aktualnaLiczba < this.pojemność && this.status === "aktywny") {
      this.aktualnaLiczba++;
      console.log(`Dodano dinozaura do zagrody ${this.nazwa}. Aktualna liczba: ${this.aktualnaLiczba}`);
      return true;
    } else {
      console.log(`Nie można dodać dinozaura do zagrody ${this.nazwa}. Zagroda pełna lub nieaktywna.`);
      return false;
    }
  }

  usuńDinozaura(): boolean {
    if (this.aktualnaLiczba > 0) {
      this.aktualnaLiczba--;
      console.log(`Usunięto dinozaura z zagrody ${this.nazwa}. Aktualna liczba: ${this.aktualnaLiczba}`);
      return true;
    } else {
      console.log(`Nie można usunąć dinozaura z zagrody ${this.nazwa}. Zagroda pusta.`);
      return false;
    }
  }
}

@RejestrujZasób("budynek")
@WymagaAudytu(30) // Audyt co 30 dni
@ŚledźStatusy
class BudynekParku implements ZasobParku {
  id: string;
  nazwa: string;
  lokalizacja: string;
  private _status: "aktywny" | "nieaktywny" | "w konserwacji" | "awaria" = "aktywny";

  // Właściwości specyficzne dla budynku
  rodzajBudynku: "publiczny" | "administracja" | "laboratorium" | "utrzymanie";
  powierzchnia: number;

  constructor(
    id: string,
    nazwa: string,
    lokalizacja: string,
    rodzajBudynku: "publiczny" | "administracja" | "laboratorium" | "utrzymanie",
    powierzchnia: number
  ) {
    this.id = id;
    this.nazwa = nazwa;
    this.lokalizacja = lokalizacja;
    this.rodzajBudynku = rodzajBudynku;
    this.powierzchnia = powierzchnia;
  }

  get status(): "aktywny" | "nieaktywny" | "w konserwacji" | "awaria" {
    return this._status;
  }

  set status(nowyStatus: "aktywny" | "nieaktywny" | "w konserwacji" | "awaria") {
    this._status = nowyStatus;
  }

  otwórz(): void {
    if (this.status !== "aktywny") {
      console.log(`Nie można otworzyć budynku ${this.nazwa}. Status: ${this.status}`);
      return;
    }

    console.log(`Otwarto budynek ${this.nazwa}`);
  }

  zamknij(): void {
    console.log(`Zamknięto budynek ${this.nazwa}`);
  }
}

@Singleton
@RejestrujZasób("system")
class SystemBezpieczeństwa implements ZasobParku {
  id: string;
  nazwa: string;
  lokalizacja: string;
  private _status: "aktywny" | "nieaktywny" | "w konserwacji" | "awaria" = "aktywny";

  // Właściwości specyficzne dla systemu bezpieczeństwa
  protokółAwaryjny: "normalny" | "ostrzeżenie" | "zagrożenie" | "ewakuacja" = "normalny";

  constructor() {
    this.id = "SYS-SEC-001";
    this.nazwa = "Główny System Bezpieczeństwa";
    this.lokalizacja = "Centrum kontroli";
  }

  get status(): "aktywny" | "nieaktywny" | "w konserwacji" | "awaria" {
    return this._status;
  }

  set status(nowyStatus: "aktywny" | "nieaktywny" | "w konserwacji" | "awaria") {
    this._status = nowyStatus;

    if (nowyStatus !== "aktywny" && this.protokółAwaryjny === "normalny") {
      console.warn("UWAGA: System bezpieczeństwa nie jest aktywny!");
      this.ustawProtokoł("ostrzeżenie");
    }
  }

  ustawProtokoł(protokół: "normalny" | "ostrzeżenie" | "zagrożenie" | "ewakuacja"): void {
    this.protokółAwaryjny = protokół;
    console.log(`Ustawiono protokół bezpieczeństwa: ${protokół}`);

    // Implementacja działań w zależności od protokołu
    switch (protokół) {
      case "normalny":
        console.log("Wszystkie systemy działają normalnie.");
        break;
      case "ostrzeżenie":
        console.log("Zwiększono czujność personelu. Sprawdzenie wszystkich systemów.");
        break;
      case "zagrożenie":
        console.log("UWAGA: Wykryto zagrożenie! Personel na pozycje! Przygotowanie do ewakuacji.");
        break;
      case "ewakuacja":
        console.log("UWAGA! UWAGA! Natychmiastowa ewakuacja parku! To nie jest ćwiczenie!");
        break;
    }
  }

  sprawdźStatus(): void {
    console.log(`Status systemu bezpieczeństwa: ${this.status}`);
    console.log(`Aktualny protokół: ${this.protokółAwaryjny}`);
  }
}

// Użycie klas z dekoratorami

// Tworzenie zagrody
const zagrodaT = new ZagrodaDinozaurów(
  "ZAG-001",
  "Zagroda T-Rex",
  "Sektor A",
  "Tyrannosaurus Rex",
  2
);

zagrodaT.dodajDinozaura();
zagrodaT.status = "w konserwacji";
zagrodaT.status = "aktywny";

// Tworzenie budynku
const centrumGości = new BudynekParku(
  "BUD-001",
  "Centrum Gości",
  "Wejście główne",
  "publiczny",
  2500
);

centrumGości.otwórz();
centrumGości.status = "w konserwacji";
centrumGości.status = "aktywny";

// Tworzenie systemu bezpieczeństwa (Singleton)
const systemBezpieczeństwa1 = new SystemBezpieczeństwa();
systemBezpieczeństwa1.sprawdźStatus();
systemBezpieczeństwa1.ustawProtokoł("ostrzeżenie");

// Próba utworzenia drugiego systemu bezpieczeństwa
const systemBezpieczeństwa2 = new SystemBezpieczeństwa();
// Zauważ, że systemBezpieczeństwa1 === systemBezpieczeństwa2

// Sprawdzenie audytów
console.log(`Zagroda T-Rex wymaga audytu: ${(zagrodaT as any).wymagaAudytu()}`);
console.log(`Centrum Gości wymaga audytu: ${(centrumGości as any).wymagaAudytu()}`);

// Przeprowadzenie audytu
if ((zagrodaT as any).wymagaAudytu()) {
  (zagrodaT as any).przeprowadźAudyt();
}

// Pobranie wszystkich zasobów z rejestru
console.log("Lista zasobów w parku:");
const wszystkieZasoby = RejestrZasobów.pobierzWszystkieZasoby();
for (const [typ, zasoby] of wszystkieZasoby) {
  console.log(`Typ: ${typ}, Liczba: ${zasoby.length}`);
  zasoby.forEach(zasób => {
    console.log(`  - ${zasób.nazwa} (${zasób.status})`);
  });
}

// Sprawdzenie historii statusów
console.log("Historia statusów zagrody T-Rex:");
(zagrodaT as any).historiaStatusów.forEach((zmiana: any) => {
  console.log(`  ${zmiana.czasZmiany.toLocaleString()}: ${zmiana.z || 'początkowy'} -> ${zmiana.na}`);
});

Ten rozbudowany przykład demonstruje zaawansowane zastosowanie dekoratorów klas:

  1. @RejestrujZasób - automatycznie rejestruje zasoby w centralnym rejestrze
  2. @WymagaAudytu - dodaje funkcjonalność śledzenia terminów audytów
  3. @ŚledźStatusy - dodaje historię zmian statusu
  4. @Singleton - zapewnia, że można utworzyć tylko jedną instancję klasy

Kiedy warto używać dekoratorów klas

Dekoratory klas są szczególnie przydatne:

  1. Gdy chcemy dodać funkcjonalność "w poprzek" - gdy ta sama funkcjonalność musi być dodana do wielu klas (tzw. programowanie aspektowe)
  2. Przy implementacji wzorców projektowych - takich jak Singleton, Factory, Observer
  3. Do automatycznej rejestracji - np. rejestracja komponentów w systemie dependency injection
  4. Przy metaprogramowaniu - gdy kod ma modyfikować sam siebie w czasie działania
  5. Do dodawania metadanych - które mogą być później wykorzystane przez framework

Ograniczenia i problemy z dekoratorami klas

Dekoratory klas mają również pewne ograniczenia i problemy:

  1. Trudniejsze debugowanie - kod z wieloma dekoratorami może być trudniejszy do debugowania
  2. Problemy z typowaniem - czasem trzeba używać as any, aby uniknąć problemów z TypeScriptem
  3. Ukryta funkcjonalność - dekoratory mogą ukrywać ważną funkcjonalność, co utrudnia zrozumienie kodu
  4. Kolejność stosowania - kolejność nakładania dekoratorów jest ważna i może powodować problemy
  5. Zmiany w specyfikacji - specyfikacja dekoratorów w JavaScript i TypeScript wciąż ewoluuje

Podsumowanie

Dekoratory klas w TypeScripcie są potężnym narzędziem, które pozwala na dodawanie, modyfikowanie lub zastępowanie funkcjonalności klas w sposób deklaratywny, bez ingerencji w ich wewnętrzną implementację. Podobnie jak specjalne protokoły bezpieczeństwa w Parku Jurajskim pomagają utrzymać porządek i kontrolę, dekoratory klas pomagają organizować i rozszerzać kod w sposób przejrzysty i systematyczny.

Dekoratory klas są szczególnie przydatne w dużych aplikacjach, gdzie często trzeba implementować funkcjonalności "w poprzek" wielu klas, takie jak logowanie, autoryzacja, walidacja czy rejestracja komponentów. Dzięki nim, możemy tworzyć bardziej modularny, elastyczny i łatwiejszy w utrzymaniu kod.

Pamiętaj jednak, że jak wszystkie potężne narzędzia, dekoratory klas powinny być używane z rozwagą. Nadużywanie ich może prowadzić do trudnego w debugowaniu i zrozumieniu kodu. Zawsze używaj ich, gdy rzeczywiście rozwiązują problem, a nie tylko dlatego, że wyglądają elegancko.

Kod do tej lekcji: index.ts
// Kompletny system typow parku - Park Jurajski
console.log("=== ZAAWANSOWANY SYSTEM TYPOW PARKU ===\n");

// ===========================================
// 1. Bazowe typy i interfejsy
// ===========================================

interface Entity {
  readonly id: string;
  readonly createdAt: Date;
}

interface Dinosaur extends Entity {
  name: string;
  species: string;
  weight: number;
  diet: "carnivore" | "herbivore" | "omnivore";
  dangerLevel: number;
}

interface Enclosure extends Entity {
  name: string;
  capacity: number;
  securityLevel: number;
  residents: string[];
}

interface StaffMember extends Entity {
  name: string;
  role: "ranger" | "veterinarian" | "researcher" | "security";
  clearanceLevel: number;
}

// ===========================================
// 2. Typy mapowane i warunkowe
// ===========================================

type EntityMap = {
  dinosaur: Dinosaur;
  enclosure: Enclosure;
  staff: StaffMember;
};

type EntityType = keyof EntityMap;

// Automatyczne tworzenie typow DTO
type CreateDTO<T extends Entity> = Omit<T, "id" | "createdAt">;
type UpdateDTO<T extends Entity> = Partial<Omit<T, "id" | "createdAt">>;
type ReadDTO<T extends Entity> = Readonly<T>;

// ===========================================
// 3. Generyczne repozytorium z constraintami
// ===========================================

class Repository<T extends Entity> {
  private storage: Map<string, T> = new Map();
  private counter = 0;
  private prefix: string;

  constructor(prefix: string) {
    this.prefix = prefix;
  }

  create(data: CreateDTO<T>): T {
    const id = `${this.prefix}-${String(++this.counter).padStart(3, "0")}`;
    const entity = { ...data, id, createdAt: new Date() } as T;
    this.storage.set(id, entity);
    return entity;
  }

  findById(id: string): ReadDTO<T> | undefined {
    return this.storage.get(id);
  }

  findAll(): ReadDTO<T>[] {
    return Array.from(this.storage.values());
  }

  update(id: string, data: UpdateDTO<T>): T | undefined {
    const existing = this.storage.get(id);
    if (!existing) return undefined;
    const updated = { ...existing, ...data } as T;
    this.storage.set(id, updated);
    return updated;
  }

  delete(id: string): boolean {
    return this.storage.delete(id);
  }

  query(predicate: (item: T) => boolean): ReadDTO<T>[] {
    return this.findAll().filter(item => predicate(item as T));
  }
}

// ===========================================
// 4. System zdarzen z conditional types
// ===========================================

type EventSeverity = "info" | "warning" | "critical";

type ParkEvent<S extends EventSeverity> = S extends "critical"
  ? { severity: S; message: string; requiresEvacuation: boolean; affectedZones: string[] }
  : S extends "warning"
  ? { severity: S; message: string; affectedZones: string[] }
  : { severity: S; message: string };

function createEvent<S extends EventSeverity>(
  severity: S,
  data: Omit<ParkEvent<S>, "severity">
): ParkEvent<S> {
  return { severity, ...data } as ParkEvent<S>;
}

// ===========================================
// 5. System raportow z mapped types
// ===========================================

type DinoReport = {
  [K in keyof Omit<Dinosaur, "id" | "createdAt">]: {
    label: string;
    value: Dinosaur[K];
    formatted: string;
  };
};

function generateReport(dino: Dinosaur): DinoReport {
  return {
    name: { label: "Nazwa", value: dino.name, formatted: dino.name },
    species: { label: "Gatunek", value: dino.species, formatted: dino.species },
    weight: { label: "Waga", value: dino.weight, formatted: `${dino.weight} kg` },
    diet: { label: "Dieta", value: dino.diet, formatted: dino.diet === "carnivore" ? "Miesozerna" : dino.diet === "herbivore" ? "Roslinozerna" : "Wszystkozerna" },
    dangerLevel: { label: "Zagrozenie", value: dino.dangerLevel, formatted: `${dino.dangerLevel}/10` }
  };
}

// ===========================================
// Test
// ===========================================

// Repozytoria
const dinoRepo = new Repository<Dinosaur>("DINO");
const encRepo = new Repository<Enclosure>("ENC");
const staffRepo = new Repository<StaffMember>("STAFF");

// Tworzenie dinozaurow
console.log("--- Tworzenie encji ---");
const rex = dinoRepo.create({ name: "Rexy", species: "T-Rex", weight: 8000, diet: "carnivore", dangerLevel: 10 });
const blue = dinoRepo.create({ name: "Blue", species: "Velociraptor", weight: 15, diet: "carnivore", dangerLevel: 8 });
const patty = dinoRepo.create({ name: "Patty", species: "Brachiosaurus", weight: 50000, diet: "herbivore", dangerLevel: 1 });

const mainEnc = encRepo.create({ name: "Strefa T-Rex", capacity: 2, securityLevel: 10, residents: [rex.id] });
const grant = staffRepo.create({ name: "Alan Grant", role: "researcher", clearanceLevel: 8 });

console.log(`Dinozaur: ${rex.id} - ${rex.name}`);
console.log(`Zagodzenie: ${mainEnc.id} - ${mainEnc.name}`);
console.log(`Pracownik: ${grant.id} - ${grant.name}`);

// Aktualizacja
console.log("\n--- Aktualizacja ---");
const updatedRex = dinoRepo.update(rex.id, { weight: 8200 });
console.log(`${updatedRex?.name}: ${updatedRex?.weight}kg`);

// Query
console.log("\n--- Zapytania ---");
const dangerousDinos = dinoRepo.query(d => d.dangerLevel >= 7);
console.log("Niebezpieczne:", dangerousDinos.map(d => d.name).join(", "));

const carnivores = dinoRepo.query(d => d.diet === "carnivore");
console.log("Miesozerne:", carnivores.map(d => d.name).join(", "));

// Zdarzenia
console.log("\n--- Zdarzenia ---");
const info = createEvent("info", { message: "Rutynowa kontrola zakonczona" });
console.log("Info:", info.message);

const warning = createEvent("warning", {
  message: "Ogrodzenie wymaga naprawy",
  affectedZones: ["Strefa A"]
});
console.log("Ostrzezenie:", warning.message, "Strefy:", warning.affectedZones.join(", "));

const critical = createEvent("critical", {
  message: "Ucieczka dinozaura!",
  requiresEvacuation: true,
  affectedZones: ["Strefa A", "Strefa B"]
});
console.log("KRYTYCZNE:", critical.message, "Ewakuacja:", critical.requiresEvacuation);

// Raport
console.log("\n--- Raport dinozaura ---");
const report = generateReport(rex);
Object.values(report).forEach(field => {
  console.log(`  ${field.label}: ${field.formatted}`);
});

console.log("\nKompletny system typow TypeScript w akcji!");

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. Który utility type służy do WYKLUCZENIA konkretnych typów z unii typów?

  2. 2. Co to jest dekorator w TypeScript?

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj kroki tworzenia własnego utility type w TypeScript:

  • Klikanie w kolejności

    Ułóż elementy deklaracji dekoratora klasy:

  1. Ułóż w kolejnościTworzenie custom utility type
  2. PytanieUtility type Exclude
  3. PytanieDekorator metody
  4. Kliknij w kolejnościSortowanie: Deklaracja dekoratora

Przydatne artykuły