Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript

Dekoratory metod i właściwości

18 min czytania ·
W tej lekcji12

"Nadzór nad poszczególnymi operacjami w Parku Jurajskim jest równie ważny, jak zarządzanie całym parkiem," wyjaśnia dr. Henry Wu, główny genetyk InGen. "Podobnie jak monitorujemy każdy aspekt życia dinozaurów - ich żywienie, zachowanie czy wzrost - tak samo musimy kontrolować i zabezpieczać poszczególne operacje w naszym systemie."

W TypeScripcie, po zrozumieniu dekoratorów klas, naturalnym krokiem jest zagłębienie się w dekoratory metod i właściwości. Te dekoratory pozwalają nam na precyzyjne modyfikowanie zachowania konkretnych członków klasy, podobnie jak w Parku Jurajskim, gdzie każda operacja, od karmienia dinozaurów po zabezpieczenia zagród, wymaga specjalnego nadzoru i protokołów.

Wprowadzenie do dekoratorów metod i właściwości

Dekoratory metod i właściwości pozwalają na modyfikowanie zachowania, dostępu lub wartości poszczególnych członków klasy. Dzięki nim możemy:

  1. Dodać dodatkowe zachowanie przed lub po wykonaniu metody
  2. Walidować parametry metod
  3. Cachować wyniki metod
  4. Mierzyć czas wykonania metod
  5. Kontrolować dostęp do właściwości
  6. Transformować wartości właściwości
  7. Dodawać metadane do metod i właściwości

Dekoratory metod

W trybie experimentalDecorators dekoratory metod są funkcjami, które przyjmują trzy parametry:

  1. target - prototyp klasy (dla metod instancji) lub konstruktor klasy (dla metod statycznych)
  2. propertyKey - nazwa metody
  3. descriptor - deskryptor właściwości dla metody

Standardowe dekoratory z TypeScriptu 5.0+ (bez tej opcji) dostają zamiast tego dwa argumenty: samą metodę i obiekt context.

Podstawowa składnia dekoratora metody:

function dekoratorMetody(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  // Modyfikacja deskryptora metody
  // Zwrócenie zmodyfikowanego deskryptora lub undefined
}

class MojaKlasa {
  @dekoratorMetody
  mojaMetoda() {
    // Implementacja metody
  }
}

Przykład: System logowania operacji w Parku Jurajskim

Zacznijmy od prostego dekoratora metody, który będzie logował wykonanie operacji w Parku Jurajskim:

// Dekorator metody logujący wywołania
function LogujOperację(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  // Zapisujemy oryginalną metodę
  const oryginalnaMetoda = descriptor.value;

  // Nadpisujemy metodę
  descriptor.value = function(...args: any[]) {
    console.log(`[${new Date().toISOString()}] Wywołanie ${propertyKey} z argumentami: ${JSON.stringify(args)}`);

    try {
      // Wywołujemy oryginalną metodę
      const wynik = oryginalnaMetoda.apply(this, args);

      // Logujemy wynik
      console.log(`[${new Date().toISOString()}] ${propertyKey} zakończone. Wynik: ${JSON.stringify(wynik)}`);

      return wynik;
    } catch (błąd) {
      // Logujemy błąd
      console.error(`[${new Date().toISOString()}] ${propertyKey} zakończone błędem: ${błąd}`);

      // Rzucamy błąd dalej
      throw błąd;
    }
  };

  return descriptor;
}

// Zastosowanie dekoratora w klasie zarządzającej zagrodami
class ZarządzanieZagrodami {
  constructor(private nazwaPracownika: string) {}

  @LogujOperację
  otwórzZagrodę(idZagrody: string): boolean {
    console.log(`${this.nazwaPracownika} otwiera zagrodę: ${idZagrody}`);
    // Tutaj logika otwierania zagrody
    return true;
  }

  @LogujOperację
  zamknijZagrodę(idZagrody: string): boolean {
    console.log(`${this.nazwaPracownika} zamyka zagrodę: ${idZagrody}`);
    // Tutaj logika zamykania zagrody
    return true;
  }

  sprawdźStan(idZagrody: string): string {
    // Ta metoda nie jest logowana
    return "Zagroda zamknięta";
  }
}

// Używamy klasy z dekorowanymi metodami
const zarządca = new ZarządzanieZagrodami("John");
zarządca.otwórzZagrodę("A-001");
zarządca.zamknijZagrodę("A-001");
zarządca.sprawdźStan("A-001"); // Ta operacja nie będzie logowana

W powyższym przykładzie, dekorator LogujOperację rejestruje każde wywołanie metody, jej argumenty oraz wynik lub błąd. Metody otwórzZagrodę i zamknijZagrodę są logowane, podczas gdy metoda sprawdźStan nie ma dekoratora, więc nie jest logowana.

Dekoratory metod z parametrami

Możemy również tworzyć dekoratory metod, które przyjmują parametry:

// Dekorator metody z parametrami
function WymagaPoziomDostępu(poziom: number) {
  return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    // Zapisujemy oryginalną metodę
    const oryginalnaMetoda = descriptor.value;

    // Nadpisujemy metodę
    descriptor.value = function(...args: any[]) {
      // Sprawdzamy, czy obiekt ma właściwość poziomDostępu
      if (!(this as any).poziomDostępu) {
        throw new Error("Obiekt nie posiada zdefiniowanego poziomu dostępu!");
      }

      // Weryfikujemy poziom dostępu
      if ((this as any).poziomDostępu < poziom) {
        throw new Error(`Wymagany poziom dostępu: ${poziom}, dostępny: ${(this as any).poziomDostępu}`);
      }

      // Wywołujemy oryginalną metodę
      return oryginalnaMetoda.apply(this, args);
    };

    return descriptor;
  };
}

// Klasa reprezentująca laboratorium
class LaboratoriumGenetyczne {
  constructor(public nazwaPracownika: string, public poziomDostępu: number) {}

  @WymagaPoziomDostępu(1)
  odczytajDaneDNA(idDinozaura: string): string {
    return `DNA dinozaura ${idDinozaura}: ACGT...`;
  }

  @WymagaPoziomDostępu(2)
  modyfikujDNA(idDinozaura: string, sekwencja: string): boolean {
    console.log(`Modyfikacja DNA dinozaura ${idDinozaura}: ${sekwencja}`);
    return true;
  }

  @WymagaPoziomDostępu(3)
  stwórzNowyGatunek(nazwa: string, bazoweDNA: string): string {
    const nowyGatunekId = `NGT-${Math.floor(Math.random() * 1000)}`;
    console.log(`Tworzenie nowego gatunku: ${nazwa} (ID: ${nowyGatunekId})`);
    return nowyGatunekId;
  }
}

// Używamy klasy z różnymi poziomami dostępu
const stażysta = new LaboratoriumGenetyczne("Tim", 1);
const naukowiec = new LaboratoriumGenetyczne("Dr. Grant", 2);
const dyrektor = new LaboratoriumGenetyczne("Dr. Wu", 3);

// Testujemy dostęp
try {
  console.log(stażysta.odczytajDaneDNA("D-001")); // Zadziała
  stażysta.modyfikujDNA("D-001", "ACGT");         // Wyrzuci błąd
} catch (błąd) {
  console.error(błąd.message);
}

try {
  naukowiec.modyfikujDNA("D-001", "ACGT");        // Zadziała
  naukowiec.stwórzNowyGatunek("Neo-Raptor", "ACGT..."); // Wyrzuci błąd
} catch (błąd) {
  console.error(błąd.message);
}

// Dyrektor ma pełny dostęp
dyrektor.stwórzNowyGatunek("Indominus Rex", "ACGT...");

W tym przykładzie, dekorator WymagaPoziomDostępu sprawdza, czy osoba wywołująca metodę ma wystarczający poziom dostępu. Różne metody wymagają różnych poziomów dostępu, co odzwierciedla rzeczywiste protokoły bezpieczeństwa, jakie mogłyby istnieć w Parku Jurajskim.

Dekoratory właściwości

Dekoratory właściwości są podobne do dekoratorów metod, ale otrzymują tylko dwa parametry:

  1. target - prototyp klasy (dla właściwości instancji) lub konstruktor klasy (dla właściwości statycznych)
  2. propertyKey - nazwa właściwości

Podstawowa składnia dekoratora właściwości:

function dekoratorWłaściwości(target: any, propertyKey: string) {
  // Implementacja dekoratora
}

class MojaKlasa {
  @dekoratorWłaściwości
  mojaWłaściwość: string;
}

Ponieważ dekoratory właściwości nie otrzymują deskryptora, często są używane do generowania getterów i setterów lub do stosowania metadanych.

Przykład: System monitorowania zasobów w Parku Jurajskim

Zaimplementujmy dekorator właściwości, który będzie monitorował zmiany zasobów w Parku Jurajskim:

// Dekorator właściwości monitorujący zmiany
function MonitorujZmiany(target: any, propertyKey: string) {
  // Tworzymy unikalną nazwę dla prywatnej właściwości
  const prywatnaNazwa = Symbol(propertyKey);

  // Definiujemy getter i setter
  Object.defineProperty(target, propertyKey, {
    get: function() {
      // Zwracamy wartość prywatnej właściwości
      return this[prywatnaNazwa];
    },
    set: function(wartość: any) {
      // Zapisujemy starą wartość
      const staraWartość = this[prywatnaNazwa];

      // Logujemy zmianę, jeśli nie jest to pierwsze przypisanie
      if (this[prywatnaNazwa] !== undefined) {
        console.log(`[ZMIANA][${this.constructor.name}] ${propertyKey}: ${staraWartość} -> ${wartość}`);
      }

      // Zapisujemy nową wartość
      this[prywatnaNazwa] = wartość;
    },
    enumerable: true,
    configurable: true
  });
}

// Klasa monitorująca zasoby parku
class ZasobyParku {
  @MonitorujZmiany
  ilośćPożywienia: number = 1000;

  @MonitorujZmiany
  stanGeneratorów: "Aktywne" | "Awaryjne" | "Wyłączone" = "Aktywne";

  @MonitorujZmiany
  statusBramy: "Otwarta" | "Zamknięta" = "Zamknięta";

  constructor(public nazwaSekcji: string) {}

  użyjPożywienia(ilość: number): boolean {
    if (this.ilośćPożywienia >= ilość) {
      this.ilośćPożywienia -= ilość;
      return true;
    }
    return false;
  }

  uzupełnijPożywienie(ilość: number): void {
    this.ilośćPożywienia += ilość;
  }

  przełączGeneratory(stan: "Aktywne" | "Awaryjne" | "Wyłączone"): void {
    this.stanGeneratorów = stan;
  }

  przełączBramę(status: "Otwarta" | "Zamknięta"): void {
    this.statusBramy = status;
  }
}

// Używamy klasy z monitorowanymi właściwościami
const sekcjaA = new ZasobyParku("Sekcja A");

// Testujemy zmiany właściwości
sekcjaA.użyjPożywienia(200);  // ilośćPożywienia: 1000 -> 800
sekcjaA.uzupełnijPożywienie(500);  // ilośćPożywienia: 800 -> 1300
sekcjaA.przełączGeneratory("Awaryjne");  // stanGeneratorów: Aktywne -> Awaryjne
sekcjaA.przełączBramę("Otwarta");  // statusBramy: Zamknięta -> Otwarta

W tym przykładzie, dekorator MonitorujZmiany tworzy getter i setter dla właściwości, które logują każdą zmianę wartości. Dzięki temu, możemy śledzić, kiedy i jakie zmiany zostały wprowadzone, co jest kluczowe dla monitorowania zasobów w parku.

Łączenie dekoratorów metod i właściwości

Możemy łączyć różne dekoratory metod i właściwości, aby stworzyć bardziej zaawansowane zachowania:

// Dekorator mierzący czas wykonania metody
function MierzCzasWykonania(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const oryginalnaMetoda = descriptor.value;

  descriptor.value = function(...args: any[]) {
    const start = performance.now();
    const wynik = oryginalnaMetoda.apply(this, args);
    const koniec = performance.now();

    console.log(`[CZAS] ${propertyKey}: ${(koniec - start).toFixed(2)}ms`);

    return wynik;
  };

  return descriptor;
}

// Dekorator walidujący parametry metody
function WalidujParametry(walidator: (args: any[]) => boolean, komunikatBłędu: string) {
  return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    const oryginalnaMetoda = descriptor.value;

    descriptor.value = function(...args: any[]) {
      if (!walidator(args)) {
        throw new Error(`[BŁĄD WALIDACJI] ${propertyKey}: ${komunikatBłędu}`);
      }

      return oryginalnaMetoda.apply(this, args);
    };

    return descriptor;
  };
}

// Dekorator cachujący wyniki metody
function Cachuj(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const oryginalnaMetoda = descriptor.value;
  const cache = new Map<string, any>();

  descriptor.value = function(...args: any[]) {
    const klucz = JSON.stringify(args);

    if (cache.has(klucz)) {
      console.log(`[CACHE] ${propertyKey}: Użyto zapisanego wyniku dla ${klucz}`);
      return cache.get(klucz);
    }

    const wynik = oryginalnaMetoda.apply(this, args);
    cache.set(klucz, wynik);

    return wynik;
  };

  return descriptor;
}

// Dekorator dodający zakres wartości dla właściwości numerycznej
function Zakres(min: number, max: number) {
  return function(target: any, propertyKey: string) {
    // Tworzymy unikalną nazwę dla prywatnej właściwości
    const prywatnaNazwa = Symbol(propertyKey);

    // Definiujemy getter i setter
    Object.defineProperty(target, propertyKey, {
      get: function() {
        return this[prywatnaNazwa];
      },
      set: function(wartość: number) {
        if (wartość < min) {
          console.warn(`[ZAKRES] ${propertyKey}: Wartość ${wartość} poniżej minimum ${min}. Ustawiam ${min}.`);
          this[prywatnaNazwa] = min;
        } else if (wartość > max) {
          console.warn(`[ZAKRES] ${propertyKey}: Wartość ${wartość} powyżej maximum ${max}. Ustawiam ${max}.`);
          this[prywatnaNazwa] = max;
        } else {
          this[prywatnaNazwa] = wartość;
        }
      },
      enumerable: true,
      configurable: true
    });
  };
}

// Klasa zarządzająca systemem ogrodzenia elektrycznego
class SystemOgrodzeniaElektrycznego {
  @Zakres(0, 10000)
  napięcie: number = 5000; // w woltach

  @Zakres(0, 100)
  zasięg: number = 50; // w metrach

  private statusAktywny: boolean = false;

  @LogujOperację
  @MierzCzasWykonania
  @WalidujParametry(
    args => args[0] >= 0 && args[0] <= 10000,
    "Nieprawidłowe napięcie. Dozwolony zakres: 0-10000V"
  )
  ustawNapięcie(noweNapięcie: number): boolean {
    // Symulacja długiej operacji dla testowania dekoratora MierzCzasWykonania
    for (let i = 0; i < 1000000; i++) {
      // Obciążamy procesor
    }

    this.napięcie = noweNapięcie;
    return true;
  }

  @LogujOperację
  @Cachuj
  pobierzStatusSystemu(idSekcji: string): { aktywny: boolean; napięcie: number; zasięg: number } {
    console.log(`Pobieranie statusu systemu dla sekcji ${idSekcji}...`);

    // Symulacja długiej operacji
    for (let i = 0; i < 500000; i++) {
      // Obciążamy procesor
    }

    return {
      aktywny: this.statusAktywny,
      napięcie: this.napięcie,
      zasięg: this.zasięg
    };
  }

  @LogujOperację
  @MierzCzasWykonania
  aktywujSystem(): boolean {
    if (this.statusAktywny) {
      console.log("System już jest aktywny");
      return false;
    }

    console.log(`Aktywacja systemu ogrodzenia elektrycznego. Napięcie: ${this.napięcie}V, Zasięg: ${this.zasięg}m`);
    this.statusAktywny = true;

    return true;
  }

  @LogujOperację
  @MierzCzasWykonania
  deaktywujSystem(): boolean {
    if (!this.statusAktywny) {
      console.log("System już jest nieaktywny");
      return false;
    }

    console.log("Deaktywacja systemu ogrodzenia elektrycznego");
    this.statusAktywny = false;

    return true;
  }
}

// Używamy klasy z wieloma dekoratorami
const systemOgrodzenia = new SystemOgrodzeniaElektrycznego();

// Testujemy różne funkcjonalności
systemOgrodzenia.ustawNapięcie(7500);  // Loguje operację, mierzy czas, waliduje parametr
systemOgrodzenia.ustawNapięcie(12000); // Wyjdzie poza zakres, zostanie ustawione 10000
systemOgrodzenia.aktywujSystem();      // Loguje operację, mierzy czas

// Testujemy cachowanie
console.log(systemOgrodzenia.pobierzStatusSystemu("A1")); // Wykona pełną operację
console.log(systemOgrodzenia.pobierzStatusSystemu("A1")); // Użyje cache
console.log(systemOgrodzenia.pobierzStatusSystemu("B2")); // Wykona pełną operację
console.log(systemOgrodzenia.pobierzStatusSystemu("B2")); // Użyje cache

// Deaktywujemy system
systemOgrodzenia.deaktywujSystem();

W tym przykładzie używamy wielu dekoratorów do stworzenia zaawansowanego systemu ogrodzenia elektrycznego:

  1. @Zakres - zapewnia, że wartości właściwości pozostają w określonym zakresie
  2. @LogujOperację - loguje wywołania metod
  3. @MierzCzasWykonania - mierzy czas wykonania metod
  4. @WalidujParametry - sprawdza poprawność parametrów metod
  5. @Cachuj - zapisuje wyniki metod w pamięci podręcznej

Metadane i refleksja z dekoratorami

TypeScript umożliwia również używanie metadanych z dekoratorami, co pozwala na bardziej zaawansowane przypadki użycia. Wymaga to włączenia opcji emitDecoratorMetadata i experimentalDecorators w pliku tsconfig.json oraz zainstalowania pakietu reflect-metadata.

Oto przykład użycia metadanych z dekoratorami:

// Potrzebujemy importować reflect-metadata na początku aplikacji
import "reflect-metadata";

// Klucze dla metadanych
const PARAMETRY_KLUCZ = Symbol("parametry");

// Dekorator parametru
function Parametr(target: any, propertyKey: string, parameterIndex: number) {
  // Pobierz istniejące metadane lub stwórz puste
  const parametry: number[] = Reflect.getOwnMetadata(PARAMETRY_KLUCZ, target, propertyKey) || [];

  // Dodaj indeks parametru do listy
  parametry.push(parameterIndex);

  // Zapisz metadane
  Reflect.defineMetadata(PARAMETRY_KLUCZ, parametry, target, propertyKey);
}

// Dekorator metody walidujący parametry
function WalidujDane(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const oryginalnaMetoda = descriptor.value;

  descriptor.value = function(...args: any[]) {
    // Pobierz typy parametrów (wymaga opcji emitDecoratorMetadata)
    const typy = Reflect.getMetadata("design:paramtypes", target, propertyKey);

    // Pobierz indeksy parametrów oznaczonych dekoratorem @Parametr
    const oznaczenieParametry: number[] = Reflect.getOwnMetadata(PARAMETRY_KLUCZ, target, propertyKey) || [];

    // Waliduj parametry
    for (const indeks of oznaczenieParametry) {
      const wartość = args[indeks];
      const typ = typy[indeks];

      // Walidacja typu
      if (wartość === null || wartość === undefined) {
        throw new Error(`Parametr #${indeks} metody ${propertyKey} nie może być null lub undefined`);
      }

      // Walidacja dla różnych typów
      if (typ === String && typeof wartość !== "string") {
        throw new Error(`Parametr #${indeks} metody ${propertyKey} musi być stringiem`);
      } else if (typ === Number && typeof wartość !== "number") {
        throw new Error(`Parametr #${indeks} metody ${propertyKey} musi być liczbą`);
      } else if (typ === Boolean && typeof wartość !== "boolean") {
        throw new Error(`Parametr #${indeks} metody ${propertyKey} musi być wartością logiczną`);
      } else if (typ === Date && !(wartość instanceof Date)) {
        throw new Error(`Parametr #${indeks} metody ${propertyKey} musi być datą`);
      }
    }

    // Wywołaj oryginalną metodę
    return oryginalnaMetoda.apply(this, args);
  };

  return descriptor;
}

// Klasa operacji na dinozaurach z metadanymi
class OperacjeDinozaurów {
  @WalidujDane
  przeprowadźBadanieZdrowia(
    idDinozaura: string,
    @Parametr dataBadania: Date,
    @Parametr temperatura: number,
    @Parametr waga: number,
    notatki?: string
  ): string {
    console.log(`Badanie dinozaura ${idDinozaura}`);
    console.log(`Data: ${dataBadania.toLocaleDateString()}`);
    console.log(`Temperatura: ${temperatura}°C`);
    console.log(`Waga: ${waga}kg`);

    if (notatki) {
      console.log(`Notatki: ${notatki}`);
    }

    return "Badanie zakończone";
  }

  @WalidujDane
  przeprowadźSzczepienie(
    @Parametr idDinozaura: string,
    @Parametr typSzczepienia: string,
    @Parametr dataSzczepienia: Date
  ): boolean {
    console.log(`Szczepienie dinozaura ${idDinozaura}`);
    console.log(`Typ szczepienia: ${typSzczepienia}`);
    console.log(`Data: ${dataSzczepienia.toLocaleDateString()}`);

    return true;
  }
}

// Używamy klasy z walidacją parametrów
const operacje = new OperacjeDinozaurów();

try {
  // Poprawne wywołanie
  operacje.przeprowadźBadanieZdrowia(
    "D-001",
    new Date(),
    38.5,
    1200,
    "Dinozaur w dobrym stanie"
  );

  // Niepoprawne wywołanie - temperatura nie jest liczbą
  operacje.przeprowadźBadanieZdrowia(
    "D-002",
    new Date(),
    "wysoka" as any, // To spowoduje błąd
    1500
  );
} catch (błąd) {
  console.error(błąd.message);
}

try {
  // Poprawne wywołanie
  operacje.przeprowadźSzczepienie(
    "D-003",
    "Szczepionka przeciw pasożytom",
    new Date()
  );

  // Niepoprawne wywołanie - data nie jest obiektem Date
  operacje.przeprowadźSzczepienie(
    "D-004",
    "Szczepionka przeciw grypie",
    "dzisiaj" as any // To spowoduje błąd
  );
} catch (błąd) {
  console.error(błąd.message);
}

W tym przykładzie używamy metadanych i refleksji do walidacji parametrów metod. Dekorator @Parametr oznacza parametry, które mają być walidowane, a dekorator @WalidujDane sprawdza typy tych parametrów przy każdym wywołaniu metody.

Praktyczny przykład: System zarządzania badaniami dinozaurów

Teraz połączmy wszystkie omówione techniki w jednym większym przykładzie - systemie zarządzania badaniami dinozaurów:

// Dekorator właściwości zapewniający unikalność ID
function UnikalneID(prefiks: string = "ID") {
  return function(target: any, propertyKey: string) {
    const generujID = () => `${prefiks}-${Date.now()}-${Math.floor(Math.random() * 1000)}`;

    Object.defineProperty(target, propertyKey, {
      get: function() {
        // Jeśli właściwość nie została jeszcze ustawiona, generujemy ID
        if (!this[`_${propertyKey}`]) {
          this[`_${propertyKey}`] = generujID();
        }
        return this[`_${propertyKey}`];
      },
      set: function(wartość: string) {
        // Pozwalamy na ustawienie tylko raz
        if (!this[`_${propertyKey}`]) {
          this[`_${propertyKey}`] = wartość;
        } else {
          console.warn(`Właściwość ${propertyKey} już została ustawiona i nie może być zmieniona.`);
        }
      },
      enumerable: true,
      configurable: true
    });
  };
}

// Dekorator metody do walidacji daty
function WalidujDataBadania(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const oryginalnaMetoda = descriptor.value;

  descriptor.value = function(...args: any[]) {
    // Zakładamy, że pierwszy argument to data badania
    const dataBadania = args[0];

    if (!(dataBadania instanceof Date)) {
      throw new Error("Pierwszy parametr musi być instancją Date");
    }

    const teraz = new Date();

    if (dataBadania > teraz) {
      throw new Error("Data badania nie może być z przyszłości");
    }

    // Sprawdzamy, czy data nie jest starsza niż 30 dni
    const trzydzieściDniWstecz = new Date();
    trzydzieściDniWstecz.setDate(trzydzieściDniWstecz.getDate() - 30);

    if (dataBadania < trzydzieściDniWstecz) {
      console.warn("Uwaga: Data badania jest starsza niż 30 dni");
    }

    return oryginalnaMetoda.apply(this, args);
  };

  return descriptor;
}

// Dekorator metody do kontroli częstotliwości badań
function KontrolujCzęstotliwość(minCzasMiędzySzczepieniamiDni: number) {
  return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    // Mapa przechowująca daty ostatnich szczepień dla każdego dinozaura
    const ostatnieSzczepienia = new Map<string, Date>();

    const oryginalnaMetoda = descriptor.value;

    descriptor.value = function(...args: any[]) {
      // Zakładamy, że pierwszy argument to ID dinozaura, a drugi to data szczepienia
      const idDinozaura = args[0];
      const dataSzczepienia = args[1];

      if (ostatnieSzczepienia.has(idDinozaura)) {
        const ostatniaSzczepionka = ostatnieSzczepienia.get(idDinozaura)!;
        const różnicaDni = Math.floor((dataSzczepienia.getTime() - ostatniaSzczepionka.getTime()) / (1000 * 60 * 60 * 24));

        if (różnicaDni < minCzasMiędzySzczepieniamiDni) {
          throw new Error(`Za wcześnie na kolejne szczepienie. Minimalny odstęp to ${minCzasMiędzySzczepieniamiDni} dni. Pozostało ${minCzasMiędzySzczepieniamiDni - różnicaDni} dni.`);
        }
      }

      // Zapisujemy datę szczepienia
      ostatnieSzczepienia.set(idDinozaura, dataSzczepienia);

      return oryginalnaMetoda.apply(this, args);
    };

    return descriptor;
  };
}

// Interfejs wyników badania
interface WynikiBadania {
  temperatura: number;  // w stopniach Celsjusza
  waga: number;         // w kilogramach
  długość: number;      // w metrach
  stanZdrowia: "Zdrowy" | "Lekkie objawy" | "Chory" | "Krytyczny";
  uwagi?: string;
}

// Klasa badania dinozaura
class BadanieDinozaura {
  @UnikalneID("BAD")
  idBadania: string;

  constructor(
    public idDinozaura: string,
    public dataBadania: Date,
    public wyniki: WynikiBadania,
    public przeprowadzającyBadanie: string
  ) {}

  @LogujOperację
  pobierzRaport(): string {
    return `
      === RAPORT BADANIA ===
      ID Badania: ${this.idBadania}
      ID Dinozaura: ${this.idDinozaura}
      Data: ${this.dataBadania.toLocaleString()}
      Przeprowadzający: ${this.przeprowadzającyBadanie}

      WYNIKI:
      - Temperatura: ${this.wyniki.temperatura}°C
      - Waga: ${this.wyniki.waga} kg
      - Długość: ${this.wyniki.długość} m
      - Stan zdrowia: ${this.wyniki.stanZdrowia}
      ${this.wyniki.uwagi ? `- Uwagi: ${this.wyniki.uwagi}` : ""}
    `;
  }
}

// Klasa szczepienia dinozaura
class SzczepienieDinozaura {
  @UnikalneID("SZCZ")
  idSzczepienia: string;

  constructor(
    public idDinozaura: string,
    public dataSzczepienia: Date,
    public rodzajSzczepionki: string,
    public dawka: number,
    public przeprowadzającySzczepienie: string
  ) {}

  @LogujOperację
  pobierzRaport(): string {
    return `
      === RAPORT SZCZEPIENIA ===
      ID Szczepienia: ${this.idSzczepienia}
      ID Dinozaura: ${this.idDinozaura}
      Data: ${this.dataSzczepienia.toLocaleString()}
      Rodzaj szczepionki: ${this.rodzajSzczepionki}
      Dawka: ${this.dawka} ml
      Przeprowadzający: ${this.przeprowadzającySzczepienie}
    `;
  }
}

// Rejestr badań i szczepień
class RejestrMedyczny {
  private badania: BadanieDinozaura[] = [];
  private szczepienia: SzczepienieDinozaura[] = [];

  @LogujOperację
  @WalidujDataBadania
  zarejestrujBadanie(
    dataBadania: Date,
    idDinozaura: string,
    temperatura: number,
    waga: number,
    długość: number,
    stanZdrowia: "Zdrowy" | "Lekkie objawy" | "Chory" | "Krytyczny",
    uwagi?: string,
    przeprowadzającyBadanie: string = "Dr. Harding"
  ): BadanieDinozaura {
    const wyniki: WynikiBadania = {
      temperatura,
      waga,
      długość,
      stanZdrowia,
      uwagi
    };

    const badanie = new BadanieDinozaura(idDinozaura, dataBadania, wyniki, przeprowadzającyBadanie);
    this.badania.push(badanie);

    console.log(`Zarejestrowano badanie: ${badanie.idBadania} dla dinozaura ${idDinozaura}`);

    return badanie;
  }

  @LogujOperację
  @KontrolujCzęstotliwość(90) // Minimum 90 dni między szczepieniami
  zarejestrujSzczepienie(
    idDinozaura: string,
    dataSzczepienia: Date,
    rodzajSzczepionki: string,
    dawka: number,
    przeprowadzającySzczepienie: string = "Dr. Harding"
  ): SzczepienieDinozaura {
    const szczepienie = new SzczepienieDinozaura(
      idDinozaura,
      dataSzczepienia,
      rodzajSzczepionki,
      dawka,
      przeprowadzającySzczepienie
    );

    this.szczepienia.push(szczepienie);

    console.log(`Zarejestrowano szczepienie: ${szczepienie.idSzczepienia} dla dinozaura ${idDinozaura}`);

    return szczepienie;
  }

  @Cachuj
  @LogujOperację
  pobierzHistorięBadań(idDinozaura: string): BadanieDinozaura[] {
    console.log(`Pobieranie historii badań dla dinozaura ${idDinozaura}...`);

    // Symulacja długiej operacji
    for (let i = 0; i < 500000; i++) {
      // Obciążamy procesor
    }

    return this.badania.filter(badanie => badanie.idDinozaura === idDinozaura)
      .sort((a, b) => b.dataBadania.getTime() - a.dataBadania.getTime());
  }

  @Cachuj
  @LogujOperację
  pobierzHistorięSzczepień(idDinozaura: string): SzczepienieDinozaura[] {
    console.log(`Pobieranie historii szczepień dla dinozaura ${idDinozaura}...`);

    // Symulacja długiej operacji
    for (let i = 0; i < 500000; i++) {
      // Obciążamy procesor
    }

    return this.szczepienia.filter(szczepienie => szczepienie.idDinozaura === idDinozaura)
      .sort((a, b) => b.dataSzczepienia.getTime() - a.dataSzczepienia.getTime());
  }

  @MierzCzasWykonania
  @LogujOperację
  generujRaportMedyczny(idDinozaura: string): string {
    const badania = this.pobierzHistorięBadań(idDinozaura);
    const szczepienia = this.pobierzHistorięSzczepień(idDinozaura);

    let raport = `=== RAPORT MEDYCZNY DINOZAURA ${idDinozaura} ===\n\n`;

    raport += `Liczba badań: ${badania.length}\n`;
    raport += `Liczba szczepień: ${szczepienia.length}\n\n`;

    if (badania.length > 0) {
      const ostatnieBadanie = badania[0];
      raport += `OSTATNIE BADANIE:\n`;
      raport += `Data: ${ostatnieBadanie.dataBadania.toLocaleString()}\n`;
      raport += `Stan zdrowia: ${ostatnieBadanie.wyniki.stanZdrowia}\n`;
      raport += `Temperatura: ${ostatnieBadanie.wyniki.temperatura}°C\n`;
      raport += `Waga: ${ostatnieBadanie.wyniki.waga} kg\n`;
      raport += `Długość: ${ostatnieBadanie.wyniki.długość} m\n`;
      if (ostatnieBadanie.wyniki.uwagi) {
        raport += `Uwagi: ${ostatnieBadanie.wyniki.uwagi}\n`;
      }
      raport += "\n";
    }

    if (szczepienia.length > 0) {
      const ostatnieSzczepienie = szczepienia[0];
      raport += `OSTATNIE SZCZEPIENIE:\n`;
      raport += `Data: ${ostatnieSzczepienie.dataSzczepienia.toLocaleString()}\n`;
      raport += `Rodzaj szczepionki: ${ostatnieSzczepienie.rodzajSzczepionki}\n`;
      raport += `Dawka: ${ostatnieSzczepienie.dawka} ml\n\n`;
    }

    raport += `HISTORIA BADAŃ:\n`;
    badania.forEach((badanie, indeks) => {
      raport += `${indeks + 1}. ${badanie.dataBadania.toLocaleDateString()} - ${badanie.wyniki.stanZdrowia}\n`;
    });

    raport += `\nHISTORIA SZCZEPIEŃ:\n`;
    szczepienia.forEach((szczepienie, indeks) => {
      raport += `${indeks + 1}. ${szczepienie.dataSzczepienia.toLocaleDateString()} - ${szczepienie.rodzajSzczepionki}\n`;
    });

    return raport;
  }
}

// Testujemy system
const rejestrMedyczny = new RejestrMedyczny();

// Rejestrujemy badania i szczepienia
try {
  // Badanie z przeszłości - OK
  const badanie1 = rejestrMedyczny.zarejestrujBadanie(
    new Date("2023-09-01"),
    "TREX-001",
    38.2,
    7500,
    12.5,
    "Zdrowy",
    "Badanie rutynowe",
    "Dr. Harding"
  );

  // Badanie z przyszłości - Błąd
  const badanie2 = rejestrMedyczny.zarejestrujBadanie(
    new Date("2025-01-01"), // przyszłość
    "TREX-001",
    39.1,
    7450,
    12.5,
    "Lekkie objawy",
    "Lekka gorączka"
  );
} catch (błąd) {
  console.error(błąd.message);
}

// Rejestrujemy szczepienia
try {
  // Pierwsze szczepienie
  const szczepienie1 = rejestrMedyczny.zarejestrujSzczepienie(
    "TREX-001",
    new Date("2023-01-15"),
    "Szczepionka przeciw grypie dinozaurów",
    50,
    "Dr. Sattler"
  );

  // Drugie szczepienie - za wcześnie, powinien być błąd
  const szczepienie2 = rejestrMedyczny.zarejestrujSzczepienie(
    "TREX-001",
    new Date("2023-03-15"), // Tylko 60 dni później, a minimum to 90 dni
    "Szczepionka przeciw pasożytom",
    30
  );
} catch (błąd) {
  console.error(błąd.message);
}

// Testujemy pobieranie danych
console.log(rejestrMedyczny.pobierzHistorięBadań("TREX-001")); // Wykonuje pełne pobieranie
console.log(rejestrMedyczny.pobierzHistorięBadań("TREX-001")); // Użyje cache

// Generujemy raport medyczny
console.log(rejestrMedyczny.generujRaportMedyczny("TREX-001"));

W tym rozbudowanym przykładzie stworzyliśmy kompleksowy system zarządzania badaniami i szczepieniami dinozaurów w Parku Jurajskim, wykorzystując różne dekoratory:

  1. @UnikalneID - zapewnia, że każde badanie i każde szczepienie ma unikalne ID
  2. @LogujOperację - loguje wywołania metod
  3. @WalidujDataBadania - sprawdza poprawność daty badania
  4. @KontrolujCzęstotliwość - zapewnia odpowiedni odstęp między szczepieniami
  5. @Cachuj - cachuje wyniki długotrwałych operacji
  6. @MierzCzasWykonania - mierzy czas generowania raportów

System ten pokazuje, jak dekoratory metod i właściwości mogą być wykorzystane do tworzenia zaawansowanych funkcjonalności biznesowych, zapewniając jednocześnie spójność kodu, bezpieczeństwo danych i wydajność.

Kiedy używać dekoratorów metod i właściwości

Dekoratory metod i właściwości są szczególnie przydatne:

  1. Gdy chcemy dodać aspektową funkcjonalność - logowanie, pomiar wydajności, walidacja
  2. Gdy chcemy cachować wyniki - dla kosztownych obliczeniowo metod
  3. Gdy potrzebujemy walidacji parametrów - sprawdzanie typów, zakresów, prawidłowości
  4. Gdy chcemy kontrolować dostęp - autoryzacja, sprawdzanie uprawnień
  5. Gdy chcemy dodać metadane - dla frameworków, ORM-ów, serializacji
  6. Gdy potrzebujemy monitorować zmiany - śledzenie zmian właściwości

Ograniczenia i problemy

Podobnie jak dekoratory klas, dekoratory metod i właściwości mają swoje ograniczenia i problemy:

  1. Trudniejsze debugowanie - kod z wieloma dekoratorami może być trudniejszy do śledzenia
  2. Problem z typowaniem - może wymagać rzutowania typów (np. używania as any)
  3. Ukryta logika - implementacja może być ukryta w dekoratorze, co utrudnia zrozumienie kodu
  4. Kolejność stosowania - kolejność dekoratorów ma znaczenie i może prowadzić do subtelnych błędów
  5. Zmiany w specyfikacji - specyfikacja dekoratorów wciąż ewoluuje w JavaScript i TypeScript

Podsumowanie

Dekoratory metod i właściwości w TypeScripcie to potężne narzędzia, które pozwalają na dodanie dodatkowej funkcjonalności do metod i właściwości klas w sposób deklaratywny. Podobnie jak protokoły operacyjne w Parku Jurajskim pomagają kontrolować poszczególne działania, dekoratory metod i właściwości pomagają kontrolować i rozszerzać zachowanie poszczególnych elementów klas.

Dzięki dekoratorom, możemy tworzyć bardziej modularne, czytelne i łatwiejsze w utrzymaniu aplikacje, izolując funkcjonalności przekrojowe takie jak logowanie, walidacja czy zabezpieczenia. W dużych projektach, dobrze zaprojektowane dekoratory mogą znacząco poprawić jakość kodu i zmniejszyć jego redundancję.

Jednakże, jak każde zaawansowane narzędzie, dekoratory metod i właściwości powinny być używane z rozwagą. Nadmierne wykorzystanie dekoratorów może prowadzić do kodu, który jest trudny do zrozumienia, debugowania i testowania. Najlepszą praktyką jest używanie ich tam, gdzie rzeczywiście przynoszą korzyści, a nie tylko dla samego faktu ich użycia.

Kod do tej lekcji: index.ts
// Dekoratory metod i wlasciwosci - Nadzor operacji Parku Jurajskiego
// Uwaga: Dekoratory wymagaja "experimentalDecorators": true w tsconfig.json

// === DEKORATOR METODY - Logowanie operacji ===
function LogOperation(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    console.log("[LOG] Wywolanie: " + propertyKey + "(" + args.join(", ") + ")");
    const startTime = Date.now();
    const result = originalMethod.apply(this, args);
    const duration = Date.now() - startTime;
    console.log("[LOG] Zakonczono: " + propertyKey + " (" + duration + "ms)");
    return result;
  };

  return descriptor;
}

// === DEKORATOR METODY - Walidacja parametrow ===
function ValidateSector(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;

  descriptor.value = function (...args: any[]) {
    const sectorId = args[0];
    if (typeof sectorId !== "string" || !/^[A-Z]\d{1,2}$/.test(sectorId)) {
      throw new Error("Nieprawidlowy sektor: " + sectorId);
    }
    return originalMethod.apply(this, args);
  };

  return descriptor;
}

// === DEKORATOR METODY - Memoizacja (cache) ===
function Memoize(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
  const originalMethod = descriptor.value;
  const cache = new Map<string, any>();

  descriptor.value = function (...args: any[]) {
    const key = JSON.stringify(args);
    if (cache.has(key)) {
      console.log("[CACHE] Wynik z cache dla " + propertyKey);
      return cache.get(key);
    }
    const result = originalMethod.apply(this, args);
    cache.set(key, result);
    return result;
  };

  return descriptor;
}

// === KLASA Z DEKORATORAMI ===
class DinosaurTracker {
  private dinosaurs: Map<string, any> = new Map();

  constructor() {
    this.dinosaurs.set("A1", { name: "Rex", species: "T-Rex", health: 95 });
    this.dinosaurs.set("B3", { name: "Blue", species: "Velociraptor", health: 88 });
    this.dinosaurs.set("C2", { name: "Bronty", species: "Brachiosaurus", health: 100 });
  }

  @LogOperation
  @ValidateSector
  checkSector(sectorId: string): any {
    const dino = this.dinosaurs.get(sectorId);
    if (!dino) return { sector: sectorId, status: "pusty" };
    return { sector: sectorId, ...dino, status: "aktywny" };
  }

  @LogOperation
  @Memoize
  calculateFeedingCost(species: string, days: number): number {
    // Symulacja kosztownych obliczen
    const costs: Record<string, number> = {
      "T-Rex": 500,
      "Velociraptor": 200,
      "Brachiosaurus": 300,
    };
    return (costs[species] || 100) * days;
  }
}

// === TESTOWANIE ===
const tracker = new DinosaurTracker();

console.log("=== Sprawdzanie sektorow ===");
console.log(tracker.checkSector("A1"));
console.log(tracker.checkSector("B3"));

console.log("\n=== Koszty karmienia ===");
console.log("T-Rex 7 dni:", tracker.calculateFeedingCost("T-Rex", 7));
console.log("T-Rex 7 dni (cache):", tracker.calculateFeedingCost("T-Rex", 7));

console.log("\n=== Walidacja sektora ===");
try {
  tracker.checkSector("invalid");
} catch (e: any) {
  console.error("Blad:", e.message);
}

// TODO: Stworz dekorator @ReadOnly ktory uniemozliwia nadpisanie metody
// TODO: Stworz dekorator @Throttle(ms) ograniczajacy czestotliwosc wywolan

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 dekorator w TypeScript otrzymuje konstruktor klasy jako argument i może go rozszerzyć lub zastąpić?

  2. 2. Jakie trzy argumenty otrzymuje dekorator metody w TypeScript w trybie experimentalDecorators?

Zadania praktyczne w grze

  • Edytor kodu

    Zaimplementuj dekorator Trackable (klasy), Authorize (metody) i MaxLength (właściwości) według instrukcji w kodzie.

  • Układanie w pionie

    Uporządkuj kroki tworzenia dekoratora metody w TypeScript (tryb experimentalDecorators):

  1. PytanieRodzaje dekoratorów
  2. PytanieDekorator metody
  3. Zadanie z kodemDekoratory - praktyka podstawowa
  4. Ułóż w kolejnościKroki tworzenia dekoratora metody

Przydatne artykuły