Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript
Dekoratory metod i właściwości
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:
- Dodać dodatkowe zachowanie przed lub po wykonaniu metody
- Walidować parametry metod
- Cachować wyniki metod
- Mierzyć czas wykonania metod
- Kontrolować dostęp do właściwości
- Transformować wartości właściwości
- Dodawać metadane do metod i właściwości
Dekoratory metod
W trybie experimentalDecorators dekoratory metod są funkcjami, które przyjmują trzy parametry:
target- prototyp klasy (dla metod instancji) lub konstruktor klasy (dla metod statycznych)propertyKey- nazwa metodydescriptor- 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 logowanaW 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:
target- prototyp klasy (dla właściwości instancji) lub konstruktor klasy (dla właściwości statycznych)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 -> OtwartaW 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:
@Zakres- zapewnia, że wartości właściwości pozostają w określonym zakresie@LogujOperację- loguje wywołania metod@MierzCzasWykonania- mierzy czas wykonania metod@WalidujParametry- sprawdza poprawność parametrów metod@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:
@UnikalneID- zapewnia, że każde badanie i każde szczepienie ma unikalne ID@LogujOperację- loguje wywołania metod@WalidujDataBadania- sprawdza poprawność daty badania@KontrolujCzęstotliwość- zapewnia odpowiedni odstęp między szczepieniami@Cachuj- cachuje wyniki długotrwałych operacji@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:
- Gdy chcemy dodać aspektową funkcjonalność - logowanie, pomiar wydajności, walidacja
- Gdy chcemy cachować wyniki - dla kosztownych obliczeniowo metod
- Gdy potrzebujemy walidacji parametrów - sprawdzanie typów, zakresów, prawidłowości
- Gdy chcemy kontrolować dostęp - autoryzacja, sprawdzanie uprawnień
- Gdy chcemy dodać metadane - dla frameworków, ORM-ów, serializacji
- 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:
- Trudniejsze debugowanie - kod z wieloma dekoratorami może być trudniejszy do śledzenia
- Problem z typowaniem - może wymagać rzutowania typów (np. używania
as any) - Ukryta logika - implementacja może być ukryta w dekoratorze, co utrudnia zrozumienie kodu
- Kolejność stosowania - kolejność dekoratorów ma znaczenie i może prowadzić do subtelnych błędów
- 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 wywolanHasł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. Który dekorator w TypeScript otrzymuje konstruktor klasy jako argument i może go rozszerzyć lub zastąpić?
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):