Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript
Dekoratory klas
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:
- Dodać metadane do klasy
- Automatycznie zarejestrować klasę w rejestrze
- Dodać metody lub właściwości do klasy
- Zmienić zachowanie konstruktora
- 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:
@Rejestrowany- rejestruje klasę w systemie@PoziomBezpieczenstwa(3)- ustawia poziom bezpieczeństwa 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:
@RejestrujZasób- automatycznie rejestruje zasoby w centralnym rejestrze@WymagaAudytu- dodaje funkcjonalność śledzenia terminów audytów@ŚledźStatusy- dodaje historię zmian statusu@Singleton- zapewnia, że można utworzyć tylko jedną instancję klasy
Kiedy warto używać dekoratorów klas
Dekoratory klas są szczególnie przydatne:
- Gdy chcemy dodać funkcjonalność "w poprzek" - gdy ta sama funkcjonalność musi być dodana do wielu klas (tzw. programowanie aspektowe)
- Przy implementacji wzorców projektowych - takich jak Singleton, Factory, Observer
- Do automatycznej rejestracji - np. rejestracja komponentów w systemie dependency injection
- Przy metaprogramowaniu - gdy kod ma modyfikować sam siebie w czasie działania
- 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:
- Trudniejsze debugowanie - kod z wieloma dekoratorami może być trudniejszy do debugowania
- Problemy z typowaniem - czasem trzeba używać
as any, aby uniknąć problemów z TypeScriptem - Ukryta funkcjonalność - dekoratory mogą ukrywać ważną funkcjonalność, co utrudnia zrozumienie kodu
- Kolejność stosowania - kolejność nakładania dekoratorów jest ważna i może powodować problemy
- 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. Który utility type służy do WYKLUCZENIA konkretnych typów z unii typów?
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: