Kurs JavaScript i TypeScript · Moduł 7: Zaawansowany TypeScript
Fabryki dekoratorów
W tej lekcji7
"Standaryzacja i wielokrotne użycie to klucz do sukcesu w parku," podkreśla Simon Masrani, nowy właściciel Parku Jurajskiego. "Potrzebujemy systemów, które można łatwo dostosować do różnych gatunków dinozaurów, różnych części parku i różnych poziomów bezpieczeństwa, ale wszystko zgodnie z jednolitymi standardami."
W świecie TypeScripta, podobnie jak w zarządzaniu Parkiem Jurajskim, często potrzebujemy tworzyć podobne, ale nieco różniące się dekoratory dla różnych przypadków użycia. Fabryki dekoratorów pozwalają nam tworzyć wysoce konfigurowalne dekoratory, które możemy dostosować do konkretnych potrzeb, zachowując jednocześnie spójną strukturę i logikę.
Wprowadzenie do fabryk dekoratorów
Fabryka dekoratorów to po prostu funkcja, która zwraca dekorator, przyjmując parametry konfiguracyjne. Pozwala to na tworzenie dekoratorów "na żądanie" z różnymi wariantami zachowania, bazując na tym samym szablonie.
Główne zalety fabryk dekoratorów:
- Wielokrotne użycie - możemy tworzyć wiele różnych dekoratorów z jednej fabryki
- Konfigurowalność - dostosowujemy zachowanie dekoratora do konkretnych potrzeb
- Spójność - wszystkie dekoratory z jednej fabryki mają tę samą strukturę i koncepcję
- Łatwiejsza konserwacja - zmiana w fabryce aktualizuje wszystkie dekoratory z niej powstałe
- Typowanie - możemy definiować parametry fabryki z precyzyjnymi typami
Podstawowa struktura fabryki dekoratorów
Fabryka dekoratorów ma zazwyczaj następującą strukturę:
// Fabryka dekoratorów klasy
function fabrykaDekoratoraKlasy(opcje: OpcjeFabryki) {
// Zwraca dekorator klasy
return function<T extends new (...args: any[]) => any>(target: T) {
// Implementacja dekoratora użyłwająca opcji
//
return target; // lub zmodyfikowana klasa
};
}
// Fabryka dekoratorów metod
function fabrykaDekoratoraMetody(opcje: OpcjeFabryki) {
// Zwraca dekorator metody
return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
// Implementacja dekoratora używająca opcji
//
return descriptor;
};
}
// Fabryka dekoratorów właściwości
function fabrykaDekoratoraWłaściwości(opcje: OpcjeFabryki) {
// Zwraca dekorator właściwości
return function(target: any, propertyKey: string) {
// Implementacja dekoratora używająca opcji
//
};
}Przykłady fabryk dekoratorów w Parku Jurajskim
Zobaczmy, jak możemy wykorzystać fabryki dekoratorów w kontekście zarządzania Parkiem Jurajskim.
Przykład 1: Fabryka dekoratorów logowania dla różnych podsystemów
// Typy podsystemów parku
type PodsystemParku = "Bezpieczeństwo" | "Zagrody" | "Laboratorium" | "Transport" | "Zasilanie";
// Poziomy logowania
type PoziomLogowania = "Debug" | "Info" | "Ostrzeżenie" | "Błąd" | "Krytyczny";
// Interfejs opcji dla fabryki dekoratorów logowania
interface OpcjeLogowania {
podsystem: PodsystemParku;
poziom: PoziomLogowania;
rejestrujKolejnośćWywołań?: boolean;
czasWykonania?: boolean;
}
// Fabryka dekoratorów logowania
function LogowanieSystemu(opcje: OpcjeLogowania) {
const { podsystem, poziom, rejestrujKolejnośćWywołań = false, czasWykonania = false } = opcje;
// Licznik wywołań dla każdej metody
const licznikWywołań: Record<string, number> = {};
// Zwracamy dekorator metody
return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
// Zapisujemy oryginalną metodę
const oryginalnaMetoda = descriptor.value;
// Definiujemy nową metodę
descriptor.value = function(...args: any[]) {
// Rejestrowanie kolejności wywołania jeśli potrzebne
if (rejestrujKolejnośćWywołań) {
if (!licznikWywołań[propertyKey]) {
licznikWywołań[propertyKey] = 0;
}
licznikWywołań[propertyKey]++;
console.log(`[${podsystem}] [Wywołanie #${licznikWywołań[propertyKey]}] ${propertyKey}`);
}
// Logowanie początkowe
console.log(`[${poziom}] [${podsystem}] Wywołanie ${propertyKey}(${JSON.stringify(args)})`);
// Pomiar czasu jeśli potrzebny
const startTime = czasWykonania ? performance.now() : 0;
try {
// Wywołanie oryginalnej metody
const wynik = oryginalnaMetoda.apply(this, args);
// Logowanie po pomyślnym wykonaniu
console.log(`[${poziom}] [${podsystem}] Zakończono ${propertyKey} - Status: Sukces`);
// Logowanie czasu wykonania jeśli potrzebne
if (czasWykonania) {
const endTime = performance.now();
console.log(`[${podsystem}] Czas wykonania ${propertyKey}: ${(endTime - startTime).toFixed(2)}ms`);
}
return wynik;
} catch (błąd) {
// Logowanie przy błędzie
console.error(`[${poziom}] [${podsystem}] Błąd w ${propertyKey}: ${błąd.message}`);
// Propagujemy błąd dalej
throw błąd;
}
};
return descriptor;
};
}
// Klasa zarządzająca systemem zagród
class SystemZagród {
// Używamy fabryki do tworzenia różnych dekoratorów logowania
@LogowanieSystemu({ podsystem: "Zagrody", poziom: "Info" })
otwórzZagrodę(idZagrody: string): boolean {
console.log(`Otwieranie zagrody ${idZagrody}`);
return true;
}
@LogowanieSystemu({ podsystem: "Zagrody", poziom: "Ostrzeżenie", czasWykonania: true })
zamknijZagrodę(idZagrody: string): boolean {
console.log(`Zamykanie zagrody ${idZagrody}`);
// Symulujemy dłuższe wykonanie
for (let i = 0; i < 1000000; i++) {
// Obciążenie procesora
}
return true;
}
@LogowanieSystemu({ podsystem: "Zagrody", poziom: "Krytyczny", rejestrujKolejnośćWywołań: true, czasWykonania: true })
tryBezpieczeństwa(idZagrody: string, powód: string): boolean {
console.log(`Aktywacja trybu bezpieczeństwa dla zagrody ${idZagrody}. Powód: ${powód}`);
// Symulujemy złożoną operację
for (let i = 0; i < 2000000; i++) {
// Obciążenie procesora
}
return true;
}
}
// Klasa zarządzająca systemem bezpieczeństwa
class SystemBezpieczeństwa {
@LogowanieSystemu({ podsystem: "Bezpieczeństwo", poziom: "Info" })
sprawdźStatus(): { status: string, aktywneAlarmy: number } {
return { status: "Normalny", aktywneAlarmy: 0 };
}
@LogowanieSystemu({ podsystem: "Bezpieczeństwo", poziom: "Ostrzeżenie", czasWykonania: true })
aktywujAlarm(obszar: string, poziom: number): boolean {
console.log(`Aktywacja alarmu w obszarze ${obszar} na poziomie ${poziom}`);
return true;
}
@LogowanieSystemu({ podsystem: "Bezpieczeństwo", poziom: "Krytyczny", rejestrujKolejnośćWywołań: true })
ewakuacja(obszar: string): boolean {
console.log(`Protokół ewakuacji dla obszaru ${obszar}`);
return true;
}
}
// Użycie klas z dekoratorami
const systemZagród = new SystemZagród();
const systemBezpieczeństwa = new SystemBezpieczeństwa();
// Testowanie
systemZagród.otwórzZagrodę("A-001");
systemZagród.zamknijZagrodę("A-001");
systemZagród.tryBezpieczeństwa("A-001", "Test protokołu");
systemZagród.tryBezpieczeństwa("A-001", "Ponowny test"); // Pokaże, że to drugie wywołanie
systemBezpieczeństwa.sprawdźStatus();
systemBezpieczeństwa.aktywujAlarm("Sektor B", 2);
systemBezpieczeństwa.ewakuacja("Sektor B");W tym przykładzie, fabryka dekoratorów LogowanieSystemu tworzy dekoratory do logowania metod, które można dostosować do różnych podsystemów, poziomów logowania oraz dodatkowych opcji, takich jak rejestrowanie kolejności wywołań czy mierzenie czasu wykonania.
Przykład 2: Fabryka dekoratorów walidacji danych
// Interfejs opcji dla fabryki dekoratorów walidacji
interface OpcjeWalidacji<T> {
walidator: (wartość: T) => boolean;
komunikatBłędu: string;
wyjątek?: typeof Error;
transformacja?: (wartość: T) => T;
}
// Fabryka dekoratorów walidacji parametrów metody
function WalidujParametr<T>(opcje: OpcjeWalidacji<T>) {
const { walidator, komunikatBłędu, wyjątek = Error, transformacja } = opcje;
// Zwracamy dekorator parametru metody
return function(target: Object, propertyKey: string, parameterIndex: number) {
// Klucz dla metadanych
const kluczWalidacji = `walidacja_${propertyKey}_param_${parameterIndex}`;
// Zapisujemy metadane walidacji
const walidacje = Reflect.getOwnMetadata(kluczWalidacji, target) || [];
// Dodajemy nową walidację
walidacje.push({
indeks: parameterIndex,
walidator,
komunikatBłędu,
wyjątek,
transformacja
});
// Zapisujemy zaktualizowane metadane
Reflect.defineMetadata(kluczWalidacji, walidacje, target);
// Patrzymy, czy już istnieje dekorator metody
if (!Reflect.hasMetadata(`walidacja_${propertyKey}_decorated`, target)) {
// Oznaczamy metodę jako już dekorowaną
Reflect.defineMetadata(`walidacja_${propertyKey}_decorated`, true, target);
// Pobieramy deskryptor metody
const oryginalnaMetoda = target[propertyKey];
// Przeładowujemy metodę
target[propertyKey] = function(...args: any[]) {
// Pobieramy wszystkie walidacje dla tej metody
const walidacje = Reflect.getOwnMetadata(kluczWalidacji, target) || [];
// Stosujemy walidacje
for (const walidacja of walidacje) {
const { indeks, walidator, komunikatBłędu, wyjątek, transformacja } = walidacja;
// Jeśli wartość jest dostarczana, walidujemy ją
if (indeks < args.length) {
const wartość = args[indeks];
// Sprawdzamy walidację
if (!walidator(wartość)) {
throw new wyjątek(`Błąd walidacji parametru ${indeks} w metodzie ${propertyKey}: ${komunikatBłędu}`);
}
// Stosujemy transformację, jeśli jest dostarczana
if (transformacja) {
args[indeks] = transformacja(wartość);
}
}
}
// Wywołujemy oryginalną metodę
return oryginalnaMetoda.apply(this, args);
};
}
};
}
// Zestaw predefiniowanych walidatorów
// Walidator niepustego stringa
function NiePusty() {
return WalidujParametr<string>({
walidator: (str) => str !== null && str !== undefined && str.trim() !== '',
komunikatBłędu: "Wartość nie może być pusta"
});
}
// Walidator minimalnej długości
function MinDługość(długość: number) {
return WalidujParametr<string>({
walidator: (str) => str !== null && str !== undefined && str.length >= długość,
komunikatBłędu: `Wartość musi mieć co najmniej ${długość} znaków`
});
}
// Walidator zakresu liczbowego
function Zakres(min: number, max: number) {
return WalidujParametr<number>({
walidator: (num) => num >= min && num <= max,
komunikatBłędu: `Wartość musi być w zakresie od ${min} do ${max}`,
// Opcjonalnie możemy ograniczyć wartość do zakresu
transformacja: (num) => Math.min(Math.max(num, min), max)
});
}
// Walidator pozytywnej liczby
function Pozytywna() {
return WalidujParametr<number>({
walidator: (num) => num > 0,
komunikatBłędu: "Wartość musi być dodatnia"
});
}
// Walidator formatu daty
function FormatDaty(format: RegExp = /^\d{4}-\d{2}-\d{2}$/) {
return WalidujParametr<string>({
walidator: (str) => format.test(str),
komunikatBłędu: "Wartość musi być w formacie daty YYYY-MM-DD"
});
}
// Klasa do zarządzania danymi dinozaurów
class ZarządzanieDinozaurami {
// Utworzenie nowego dinozaura
dodajDinozaura(
@NiePusty() @MinDługość(3) nazwa: string,
@NiePusty() gatunek: string,
@Pozytywna() @Zakres(0, 100) wiek: number,
@Pozytywna() waga: number,
@FormatDaty() dataDodania: string
): string {
const idDinozaura = `DINO-${Date.now()}`;
console.log(`Dodano nowego dinozaura:`);
console.log(`- ID: ${idDinozaura}`);
console.log(`- Nazwa: ${nazwa}`);
console.log(`- Gatunek: ${gatunek}`);
console.log(`- Wiek: ${wiek} lat`);
console.log(`- Waga: ${waga} kg`);
console.log(`- Data dodania: ${dataDodania}`);
return idDinozaura;
}
// Aktualizacja danych dinozaura
aktualizujDinozaura(
@NiePusty() idDinozaura: string,
@Zakres(0, 100) wiek?: number,
@Pozytywna() waga?: number
): boolean {
console.log(`Aktualizacja dinozaura ${idDinozaura}:`);
if (wiek !== undefined) {
console.log(`- Nowy wiek: ${wiek} lat`);
}
if (waga !== undefined) {
console.log(`- Nowa waga: ${waga} kg`);
}
return true;
}
// Przeniesienie dinozaura do nowej zagrody
przenieśDinozaura(
@NiePusty() idDinozaura: string,
@NiePusty() doZagrody: string,
@FormatDaty() dataPrzeniesienia: string
): boolean {
console.log(`Przeniesienie dinozaura ${idDinozaura} do zagrody ${doZagrody} w dniu ${dataPrzeniesienia}`);
return true;
}
}
// Testowanie klasy z walidacją parametrów
const zarządzanieDino = new ZarządzanieDinozaurami();
try {
// Poprawne wywołanie
zarządzanieDino.dodajDinozaura(
"Blue",
"Velociraptor",
5,
150,
"2023-09-15"
);
// Błędne wywołanie - puste imię
zarządzanieDino.dodajDinozaura(
"", // Puste imię
"Tyrannosaurus",
8,
7500,
"2023-09-15"
);
} catch (błąd) {
console.error(błąd.message);
}
try {
// Poprawne wywołanie
zarządzanieDino.aktualizujDinozaura("DINO-123", 6, 160);
// Błędne wywołanie - ujemna waga
zarządzanieDino.aktualizujDinozaura("DINO-123", 6, -100);
} catch (błąd) {
console.error(błąd.message);
}
try {
// Poprawne wywołanie
zarządzanieDino.przenieśDinozaura("DINO-123", "B-002", "2023-09-20");
// Błędne wywołanie - nieprawidłowy format daty
zarządzanieDino.przenieśDinozaura("DINO-123", "B-003", "20/09/2023");
} catch (błąd) {
console.error(błąd.message);
}W tym przykładzie stworzyliśmy fabrykę dekoratorów walidacji parametrów, która pozwala na tworzenie różnych walidatorów, takich jak NiePusty, MinDługość, Zakres, Pozytywna i FormatDaty. Dzięki temu możemy łatwo zastosować walidację do parametrów metod w sposób deklaratywny.
Przykład 3: Fabryka dekoratorów uprawnień
// Poziomy uprawnień w parku
enum PoziomUprawnień {
Gość = 0,
Pracownik = 1,
Kierownik = 2,
Administrator = 3
}
// Akcje w systemie
type AkcjaSystemu = "odczyt" | "zapis" | "usuwanie" | "administracja";
// Mapowanie poziomów uprawnień na dozwolone akcje
const mapaUprawnień: Record<PoziomUprawnień, AkcjaSystemu[]> = {
[PoziomUprawnień.Gość]: ["odczyt"],
[PoziomUprawnień.Pracownik]: ["odczyt", "zapis"],
[PoziomUprawnień.Kierownik]: ["odczyt", "zapis", "usuwanie"],
[PoziomUprawnień.Administrator]: ["odczyt", "zapis", "usuwanie", "administracja"]
};
// Interfejs dla kontekstu bezpieczeństwa
interface KontekstBezpieczeństwa {
użytkownik: string;
poziomUprawnień: PoziomUprawnień;
tokeny?: string[];
}
// Błąd braku uprawnień
class BłądUprawnień extends Error {
constructor(akcja: string, wymaganyPoziom: PoziomUprawnień, aktualnyPoziom: PoziomUprawnień) {
super(`Brak uprawnień do akcji ${akcja}. Wymagany poziom: ${PoziomUprawnień[wymaganyPoziom]}, posiadany: ${PoziomUprawnień[aktualnyPoziom]}`);
this.name = "BłądUprawnień";
}
}
// Fabryka dekoratorów uprawnień
function WymagaUprawnienia(wymaganaAkcja: AkcjaSystemu, komunikatBłędu?: string) {
return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const oryginalnaMetoda = descriptor.value;
descriptor.value = function(this: { kontekstBezpieczeństwa?: KontekstBezpieczeństwa }, ...args: any[]) {
// Sprawdzamy, czy mamy kontekst bezpieczeństwa
if (!this.kontekstBezpieczeństwa) {
throw new Error("Brak kontekstu bezpieczeństwa");
}
const { poziomUprawnień } = this.kontekstBezpieczeństwa;
// Sprawdzamy, czy użytkownik ma akcję dla swojego poziomu uprawnień
const dozwoloneAkcje = mapaUprawnień[poziomUprawnień] || [];
if (!dozwoloneAkcje.includes(wymaganaAkcja)) {
// Znajdujemy minimalny poziom uprawnień potrzebny dla tej akcji
let minimalnyPoziom: PoziomUprawnień = PoziomUprawnień.Administrator;
for (const [poziom, akcje] of Object.entries(mapaUprawnień)) {
if (akcje.includes(wymaganaAkcja) && Number(poziom) < minimalnyPoziom) {
minimalnyPoziom = Number(poziom) as PoziomUprawnień;
}
}
throw new BłądUprawnień(
wymaganaAkcja,
minimalnyPoziom,
poziomUprawnień
);
}
// Wywołujemy oryginalną metodę
return oryginalnaMetoda.apply(this, args);
};
return descriptor;
};
}
// Uproszczone wersje dla często używanych poziomów
function DlaGości() {
return WymagaUprawnienia("odczyt");
}
function DlaPracowników() {
return WymagaUprawnienia("zapis");
}
function DlaKierowników() {
return WymagaUprawnienia("usuwanie");
}
function DlaAdministratorów() {
return WymagaUprawnienia("administracja");
}
// Klasa systemu zarządzania parkiem
class SystemZarządzaniaParkiem {
kontekstBezpieczeństwa?: KontekstBezpieczeństwa;
constructor() {
// Domyślnie brak kontekstu bezpieczeństwa
}
// Metoda do ustawiania kontekstu bezpieczeństwa
zaloguj(użytkownik: string, poziomUprawnień: PoziomUprawnień): void {
this.kontekstBezpieczeństwa = { użytkownik, poziomUprawnień };
console.log(`Zalogowano użytkownika ${użytkownik} z poziomem uprawnień: ${PoziomUprawnień[poziomUprawnień]}`);
}
// Metoda dostępna dla wszystkich
@DlaGości()
pobierzInformacjePubliczne(): string {
return "Informacje publiczne o parku";
}
// Metoda dostępna dla pracowników i wyżej
@DlaPracowników()
aktualizujDaneDinozaura(idDinozaura: string, dane: any): boolean {
console.log(`Aktualizacja danych dinozaura ${idDinozaura}`);
return true;
}
// Metoda dostępna dla kierowników i wyżej
@DlaKierowników()
usuńDinozaura(idDinozaura: string): boolean {
console.log(`Usunięcie dinozaura ${idDinozaura}`);
return true;
}
// Metoda dostępna tylko dla administratorów
@DlaAdministratorów()
zmianaKonfiguracji(klucz: string, wartość: any): boolean {
console.log(`Zmiana konfiguracji: ${klucz} = ${wartość}`);
return true;
}
// Metoda z bezpośrednim użyciem fabryki
@WymagaUprawnienia("administracja", "Tylko administratorzy mogą restartować system")
restartSystemu(): boolean {
console.log("Restartowanie systemu...");
return true;
}
}
// Testowanie systemu uprawnień
const system = new SystemZarządzaniaParkiem();
// Test dla gościa
console.log("--- Test dla gościa ---");
system.zaloguj("JohnVisitor", PoziomUprawnień.Gość);
try {
console.log(system.pobierzInformacjePubliczne()); // Powinno działać
system.aktualizujDaneDinozaura("DINO-123", { wiek: 5 }); // Powinno dać błąd
} catch (błąd) {
console.error(błąd.message);
}
// Test dla pracownika
console.log("\n--- Test dla pracownika ---");
system.zaloguj("JaneEmployee", PoziomUprawnień.Pracownik);
try {
console.log(system.pobierzInformacjePubliczne()); // Powinno działać
system.aktualizujDaneDinozaura("DINO-123", { wiek: 5 }); // Powinno działać
system.usuńDinozaura("DINO-123"); // Powinno dać błąd
} catch (błąd) {
console.error(błąd.message);
}
// Test dla kierownika
console.log("\n--- Test dla kierownika ---");
system.zaloguj("BobManager", PoziomUprawnień.Kierownik);
try {
system.usuńDinozaura("DINO-123"); // Powinno działać
system.zmianaKonfiguracji("maxDino", 100); // Powinno dać błąd
} catch (błąd) {
console.error(błąd.message);
}
// Test dla administratora
console.log("\n--- Test dla administratora ---");
system.zaloguj("AliceAdmin", PoziomUprawnień.Administrator);
try {
system.zmianaKonfiguracji("maxDino", 100); // Powinno działać
system.restartSystemu(); // Powinno działać
} catch (błąd) {
console.error(błąd.message);
}W tym przykładzie stworzyliśmy fabrykę dekoratorów uprawnień, która umożliwia kontrolowanie dostępu do metod na podstawie poziomów uprawnień użytkowników. Na jej podstawie stworzyliśmy uproszczone dekoratory dla często używanych poziomów uprawnień, takie jak DlaGości, DlaPracowników, DlaKierowników i DlaAdministratorów.
Przykład 4: Fabryka dekoratorów zarządzania zasobami
// Typy zasobów parku
type TypZasobu = "dinozaur" | "zagroda" | "budynek" | "pojazd" | "sprzęt";
// Interfejs śledzenia wykorzystania zasobów
interface ŚledzioneWykorzystanie {
zasobId: string;
typ: TypZasobu;
czasRozpoczęcia: Date;
czasZakończenia?: Date;
użytkownik: string;
status: "wUżyciu" | "zakończone" | "anulowane";
}
// Globalny rejestr wykorzystania zasobów
class RejestrWykorzystaniaZasobów {
private static instancja: RejestrWykorzystaniaZasobów;
private historia: ŚledzioneWykorzystanie[] = [];
private aktywneWykorzystanie: Map<string, ŚledzioneWykorzystanie> = new Map();
private constructor() {}
// Metoda do pobrania singletona
static pobierzInstancję(): RejestrWykorzystaniaZasobów {
if (!RejestrWykorzystaniaZasobów.instancja) {
RejestrWykorzystaniaZasobów.instancja = new RejestrWykorzystaniaZasobów();
}
return RejestrWykorzystaniaZasobów.instancja;
}
// Metoda do rozpoczynania śledzenia
rozpocznijŚledzenie(zasobId: string, typ: TypZasobu, użytkownik: string): string {
const idUżycia = `USE-${Date.now()}-${Math.floor(Math.random() * 1000)}`;
const śledzenie: ŚledzioneWykorzystanie = {
zasobId,
typ,
czasRozpoczęcia: new Date(),
użytkownik,
status: "wUżyciu"
};
this.aktywneWykorzystanie.set(idUżycia, śledzenie);
console.log(`Rozpoczęto śledzenie zasobu ${typ} ${zasobId} przez ${użytkownik}`);
return idUżycia;
}
// Metoda do zakończenia śledzenia
zakończŚledzenie(idUżycia: string, sukces: boolean = true): boolean {
if (!this.aktywneWykorzystanie.has(idUżycia)) {
console.warn(`Nie znaleziono aktywnego śledzenia dla ID: ${idUżycia}`);
return false;
}
const śledzenie = this.aktywneWykorzystanie.get(idUżycia)!;
śledzenie.czasZakończenia = new Date();
śledzenie.status = sukces ? "zakończone" : "anulowane";
this.historia.push(śledzenie);
this.aktywneWykorzystanie.delete(idUżycia);
console.log(`Zakończono śledzenie zasobu ${śledzenie.typ} ${śledzenie.zasobId} przez ${śledzenie.użytkownik} ze statusem: ${śledzenie.status}`);
return true;
}
// Metoda do sprawdzania, czy zasób jest aktualnie używany
czyZasóbWUżyciu(zasobId: string, typ: TypZasobu): boolean {
for (const [idUżycia, śledzenie] of this.aktywneWykorzystanie.entries()) {
if (śledzenie.zasobId === zasobId && śledzenie.typ === typ) {
return true;
}
}
return false;
}
// Metoda do pobierania historii użycia zasobu
pobierzHistorięZasobu(zasobId: string, typ: TypZasobu): ŚledzioneWykorzystanie[] {
return this.historia.filter(śledzenie =>
śledzenie.zasobId === zasobId && śledzenie.typ === typ
);
}
// Metoda do pobierania liczby aktywnych użyć
liczbaAktywnychUżyć(): number {
return this.aktywneWykorzystanie.size;
}
}
// Interfejs opcji dla fabryki dekoratorów zasobów
interface OpcjeŚledzeniaZasobów {
typZasobu: TypZasobu;
sprawdźDostępność?: boolean;
indeksIdZasobu?: number;
komunikatNiedostępności?: string;
}
// Fabryka dekoratorów śledzenia zasobów
function ŚledzioneWykorzystanieZasobu(opcje: OpcjeŚledzeniaZasobów) {
const {
typZasobu,
sprawdźDostępność = false,
indeksIdZasobu = 0,
komunikatNiedostępności = "Zasób jest obecnie niedostępny"
} = opcje;
return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const oryginalnaMetoda = descriptor.value;
descriptor.value = function(...args: any[]) {
// Pobieramy ID zasobu z parametrów
const zasobId = args[indeksIdZasobu];
if (!zasobId) {
throw new Error(`Nie podano ID zasobu (parametr #${indeksIdZasobu})`);
}
// Pobieramy rejestr
const rejestr = RejestrWykorzystaniaZasobów.pobierzInstancję();
// Jeśli trzeba sprawdzić dostępność
if (sprawdźDostępność && rejestr.czyZasóbWUżyciu(zasobId, typZasobu)) {
throw new Error(`${komunikatNiedostępności} (${typZasobu} ${zasobId})`);
}
// Pobieramy nazwę użytkownika z obiektu, jeśli dostępna
const użytkownik = this.użytkownik || "system";
// Rozpoczynamy śledzenie
const idUżycia = rejestr.rozpocznijŚledzenie(zasobId, typZasobu, użytkownik);
try {
// Wywołujemy oryginalną metodę
const wynik = oryginalnaMetoda.apply(this, args);
// Kończymy śledzenie z sukcesem
rejestr.zakończŚledzenie(idUżycia, true);
return wynik;
} catch (błąd) {
// Kończymy śledzenie z błędem
rejestr.zakończŚledzenie(idUżycia, false);
// Propagujemy błąd dalej
throw błąd;
}
};
return descriptor;
};
}
// Funkcje pomocnicze dla często używanych typów zasobów
function ŚledzioneWykorzystanieDinozaura(opcje: Omit<OpcjeŚledzeniaZasobów, "typZasobu"> = {}) {
return ŚledzioneWykorzystanieZasobu({ ...opcje, typZasobu: "dinozaur" });
}
function ŚledzioneWykorzystanieZagrody(opcje: Omit<OpcjeŚledzeniaZasobów, "typZasobu"> = {}) {
return ŚledzioneWykorzystanieZasobu({ ...opcje, typZasobu: "zagroda" });
}
function ŚledzioneWykorzystaniePojazdu(opcje: Omit<OpcjeŚledzeniaZasobów, "typZasobu"> = {}) {
return ŚledzioneWykorzystanieZasobu({
...opcje,
typZasobu: "pojazd",
sprawdźDostępność: true,
komunikatNiedostępności: "Pojazd jest obecnie w użyciu"
});
}
function ŚledzioneWykorzystanieSprzętu(opcje: Omit<OpcjeŚledzeniaZasobów, "typZasobu"> = {}) {
return ŚledzioneWykorzystanieZasobu({
...opcje,
typZasobu: "sprzęt",
sprawdźDostępność: true,
komunikatNiedostępności: "Sprzęt jest obecnie w użyciu"
});
}
// Klasa zarządzania zasobami parku
class ZarządzanieZasobamiParku {
użytkownik: string;
constructor(użytkownik: string) {
this.użytkownik = użytkownik;
}
// Śledzenie badania dinozaura
@ŚledzioneWykorzystanieDinozaura()
przeprowadźBadanieDinozaura(idDinozaura: string): { status: string, temperatura: number } {
console.log(`Przeprowadzanie badania dinozaura ${idDinozaura}`);
// Symulacja długiego procesu
for (let i = 0; i < 1000000; i++) {
// Obciążenie procesora
}
return { status: "zdrowy", temperatura: 38.5 };
}
// Śledzenie karmienia dinozaura
@ŚledzioneWykorzystanieDinozaura()
nakarmDinozaura(idDinozaura: string, typPokarmu: string, ilość: number): boolean {
console.log(`Karmienie dinozaura ${idDinozaura} pokarmem ${typPokarmu} (${ilość} kg)`);
// Symulacja procesu
for (let i = 0; i < 500000; i++) {
// Obciążenie procesora
}
return true;
}
// Śledzenie kontroli zagrody
@ŚledzioneWykorzystanieZagrody()
skontrolujZagrodę(idZagrody: string): { status: string, problemy: string[] } {
console.log(`Kontrola zagrody ${idZagrody}`);
// Symulacja kontroli
for (let i = 0; i < 800000; i++) {
// Obciążenie procesora
}
return { status: "OK", problemy: [] };
}
// Śledzenie wykorzystania pojazdu
@ŚledzioneWykorzystaniePojazdu()
użyjPojazdu(idPojazdu: string, cel: string): boolean {
console.log(`Użycie pojazdu ${idPojazdu} do celu: ${cel}`);
// Symulacja jazdy
for (let i = 0; i < 1500000; i++) {
// Obciążenie procesora
}
return true;
}
// Śledzenie wykorzystania sprzętu
@ŚledzioneWykorzystanieSprzętu({ indeksIdZasobu: 1 })
użyjSprzętu(cel: string, idSprzętu: string): boolean {
console.log(`Użycie sprzętu ${idSprzętu} do celu: ${cel}`);
// Symulacja użycia
for (let i = 0; i < 700000; i++) {
// Obciążenie procesora
}
return true;
}
// Bezpośrednie użycie fabryki z niestandardowymi opcjami
@ŚledzioneWykorzystanieZasobu({
typZasobu: "budynek",
sprawdźDostępność: true,
indeksIdZasobu: 0,
komunikatNiedostępności: "Budynek jest obecnie w konserwacji"
})
przeprowadźKonserwacjęBudynku(idBudynku: string, typKonserwacji: string): boolean {
console.log(`Konserwacja budynku ${idBudynku}: ${typKonserwacji}`);
// Symulacja konserwacji
for (let i = 0; i < 2000000; i++) {
// Obciążenie procesora
}
return true;
}
}
// Testowanie systemu śledzenia zasobów
async function testŚledzeniaZasobów() {
const pracownik1 = new ZarządzanieZasobamiParku("John");
const pracownik2 = new ZarządzanieZasobamiParku("Alice");
// Test badania dinozaura
console.log("--- Test badania dinozaura ---");
await pracownik1.przeprowadźBadanieDinozaura("DINO-001");
// Test karmienia dinozaura
console.log("\n--- Test karmienia dinozaura ---");
await pracownik2.nakarmDinozaura("DINO-001", "mięso", 50);
// Test kontroli zagrody
console.log("\n--- Test kontroli zagrody ---");
await pracownik1.skontrolujZagrodę("ZAG-001");
// Test użycia pojazdu
console.log("\n--- Test użycia pojazdu ---");
try {
// Pierwszy pracownik używa pojazdu
console.log("Pracownik 1 używa pojazdu...");
const obietnica1 = pracownik1.użyjPojazdu("JEEP-001", "Obchód parku");
// Próbujemy użyć tego samego pojazdu przez drugiego pracownika
console.log("Próba użycia tego samego pojazdu przez Pracownika 2...");
const obietnica2 = pracownik2.użyjPojazdu("JEEP-001", "Transport");
await Promise.all([obietnica1, obietnica2]);
} catch (błąd) {
console.error(`Błąd: ${błąd.message}`);
}
// Test użycia sprzętu
console.log("\n--- Test użycia sprzętu ---");
await pracownik1.użyjSprzętu("Badanie", "EQUIP-001");
// Test konserwacji budynku
console.log("\n--- Test konserwacji budynku ---");
await pracownik2.przeprowadźKonserwacjęBudynku("BLD-001", "Elektryka");
// Sprawdzamy liczbę aktywnych użyć
const rejestr = RejestrWykorzystaniaZasobów.pobierzInstancję();
console.log(`\nLiczba aktywnych użyć: ${rejestr.liczbaAktywnychUżyć()}`);
// Sprawdzamy historię zasobu
console.log("\nHistoria dinozaura DINO-001:");
const historiaDino = rejestr.pobierzHistorięZasobu("DINO-001", "dinozaur");
console.log(`Liczba wpisów: ${historiaDino.length}`);
historiaDino.forEach((wpis, indeks) => {
console.log(`[${indeks + 1}] ${wpis.użytkownik}: ${new Date(wpis.czasRozpoczęcia).toLocaleTimeString()} - ${wpis.czasZakończenia ? new Date(wpis.czasZakończenia).toLocaleTimeString() : 'w toku'}`);
});
}
// Uruchomienie testu
testŚledzeniaZasobów();W tym przykładzie stworzyliśmy fabrykę dekoratorów do śledzenia wykorzystania zasobów w Parku Jurajskim. Fabryka ŚledzioneWykorzystanieZasobu tworzy dekoratory, które automatycznie rejestrują rozpoczęcie i zakończenie korzystania z zasobu, a także mogą sprawdzać jego dostępność. Na jej podstawie stworzyliśmy uproszczone dekoratory dla często używanych typów zasobów, takie jak ŚledzioneWykorzystanieDinozaura, ŚledzioneWykorzystanieZagrody, ŚledzioneWykorzystaniePojazdu i ŚledzioneWykorzystanieSprzętu.
Łączenie fabryk dekoratorów
Jedną z największych zalet fabryk dekoratorów jest możliwość ich łączenia, co pozwala na tworzenie bardziej złożonych i elastycznych rozwiązań.
// Łączenie fabryk dekoratorów
function PełneŚledzenie(typZasobu: TypZasobu, poziomLogowania: PoziomLogowania = "Info") {
return function(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
// Najpierw zastosuj logowanie
LogowanieSystemu({
podsystem: typZasobu === "dinozaur" ? "Dinozaury" :
typZasobu === "zagroda" ? "Zagrody" :
typZasobu === "pojazd" ? "Transport" :
typZasobu === "sprzęt" ? "Wyposażenie" : "System",
poziom: poziomLogowania,
czasWykonania: true
})(target, propertyKey, descriptor);
// Następnie zastosuj śledzenie zasobów
return ŚledzioneWykorzystanieZasobu({
typZasobu,
sprawdźDostępność: typZasobu === "pojazd" || typZasobu === "sprzęt"
})(target, propertyKey, descriptor);
};
}
// Przykład użycia połączonych fabryk
class ZarządzanieParkiemV2 {
użytkownik: string;
kontekstBezpieczeństwa?: KontekstBezpieczeństwa;
constructor(użytkownik: string, poziomUprawnień: PoziomUprawnień) {
this.użytkownik = użytkownik;
this.kontekstBezpieczeństwa = { użytkownik, poziomUprawnień };
}
// Łączymy śledzenie zasobów, logowanie i uprawnienia
@DlaPracowników()
@PełneŚledzenie("dinozaur", "Info")
opiekujSięDinozaurem(idDinozaura: string): boolean {
console.log(`Opieka nad dinozaurem ${idDinozaura}`);
return true;
}
// Łączymy śledzenie zasobów, logowanie i uprawnienia z wyższym poziomem
@DlaKierowników()
@PełneŚledzenie("zagroda", "Ostrzeżenie")
modyfikujUstawieniaZagrody(idZagrody: string, ustawienia: any): boolean {
console.log(`Modyfikacja ustawień zagrody ${idZagrody}`);
return true;
}
// Łączymy wszystkie potrzebne dekoratory dla krytycznej funkcji
@DlaAdministratorów()
@PełneŚledzenie("sprzęt", "Krytyczny")
konfigurujSystemyBezpieczeństwa(idSprzętu: string, parametry: any): boolean {
console.log(`Konfiguracja systemów bezpieczeństwa za pomocą ${idSprzętu}`);
return true;
}
}
// Test łączenia fabryk dekoratorów
function testŁączeniaFabryk() {
console.log("=== Test łączenia fabryk dekoratorów ===");
const pracownik = new ZarządzanieParkiemV2("Mary", PoziomUprawnień.Pracownik);
const kierownik = new ZarządzanieParkiemV2("Bob", PoziomUprawnień.Kierownik);
const admin = new ZarządzanieParkiemV2("Alice", PoziomUprawnień.Administrator);
// Test pracownika
console.log("\n--- Test pracownika ---");
try {
pracownik.opiekujSięDinozaurem("DINO-002"); // Powinno działać
pracownik.modyfikujUstawieniaZagrody("ZAG-002", { temperatura: 30 }); // Powinno dać błąd
} catch (błąd) {
console.error(błąd.message);
}
// Test kierownika
console.log("\n--- Test kierownika ---");
try {
kierownik.modyfikujUstawieniaZagrody("ZAG-002", { temperatura: 30 }); // Powinno działać
kierownik.konfigurujSystemyBezpieczeństwa("SEC-001", { poziom: "wysoki" }); // Powinno dać błąd
} catch (błąd) {
console.error(błąd.message);
}
// Test administratora
console.log("\n--- Test administratora ---");
try {
admin.konfigurujSystemyBezpieczeństwa("SEC-001", { poziom: "wysoki" }); // Powinno działać
} catch (błąd) {
console.error(błąd.message);
}
}
// Uruchomienie testu
testŁączeniaFabryk();W tym przykładzie pokazujemy, jak można łączyć różne fabryki dekoratorów, tworząc kompleksowe rozwiązania. Funkcja PełneŚledzenie łączy dekoratory logowania i śledzenia zasobów, a następnie jest używana razem z dekoratorami uprawnień.
Najlepsze praktyki przy tworzeniu fabryk dekoratorów
1. Zachowaj spójność struktury
Staraj się, aby wszystkie fabryki dekoratorów miały podobną strukturę i konwencję nazewnictwa. Dzięki temu, kod będzie bardziej czytelny i przewidywalny.
// Spójna struktura fabryk dekoratorów
function LogowanieDanych(opcje: OpcjeLogowania) { /* ... */ }
function WalidacjaDanych(opcje: OpcjeWalidacji) { /* ... */ }
function ŚledzenieDanych(opcje: OpcjeŚledzenia) { /* ... */ }2. Używaj odpowiednich typów dla parametrów
Zawsze określaj dokładne typy dla parametrów fabryki, aby zapewnić bezpieczeństwo typów i wsparcie IDE.
// Dobre typowanie
interface OpcjeWalidacji<T> {
walidator: (wartość: T) => boolean;
komunikat: string;
}
function Waliduj<T>(opcje: OpcjeWalidacji<T>) {
//
}3. Zapewnij sensowne wartości domyślne
Fabryki dekoratorów powinny mieć rozsądne wartości domyślne dla opcji, które nie są krytyczne.
function LogujOperację(opcje: Partial<OpcjeLogowania> = {}) {
const {
poziom = "Info",
szczegółowy = false,
czasWykonania = false
} = opcje;
//
}4. Twórz uproszczone wersje dla często używanych przypadków
Dla często używanych konfiguracji, twórz specjalizowane fabryki, które ułatwią używanie dekoratorów.
// Specjalizowane wersje dla różnych poziomów logowania
function LogujDebug(szczegółowy: boolean = false) {
return LogujOperację({ poziom: "Debug", szczegółowy });
}
function LogujInfo() {
return LogujOperację({ poziom: "Info" });
}
function LogujOstrzeżenie() {
return LogujOperację({ poziom: "Ostrzeżenie", czasWykonania: true });
}
function LogujBłąd() {
return LogujOperację({ poziom: "Błąd", szczegółowy: true, czasWykonania: true });
}5. Dokumentuj swoje fabryki
Dobrze udokumentowane fabryki dekoratorów ułatwiają ich używanie.
/**
* Tworzy dekorator, który waliduje parametr metody.
*
* @param opcje - Opcje walidacji
* @param opcje.walidator - Funkcja sprawdzająca poprawność wartości
* @param opcje.komunikat - Komunikat błędu w przypadku niepoprawnej wartości
* @param opcje.transformacja - Opcjonalna funkcja przekształcająca wartość
*
* @returns Dekorator parametru metody
*
* @example
* class Przykład {
* metoda(@Waliduj({ walidator: (x) => x > 0, komunikat: "Musi być dodatnia" }) liczba: number) {
* //
* }
* }
*/
function Waliduj<T>(opcje: OpcjeWalidacji<T>) {
//
}6. Unikaj ukrytych zależności
Fabryki dekoratorów powinny być jawne w swoich zależnościach.
// Źle - ukryta zależność
function LogujDoPliku(ścieżkaPliku: string) {
// Bezpośrednio używa systemu plików
const fs = require('fs');
//
}
// Dobrze - jawna zależność
function LogujDoPliku(logger: FileLogger) {
// Logger jest przekazywany jako parametr
//
}7. Testuj swoje fabryki dekoratorów
Pisz testy jednostkowe dla swoich fabryk dekoratorów, aby upewnić się, że działają jak oczekiwano.
describe('WalidujZakres', () => {
it('powinien przepuścić wartość w zakresie', () => {
//
});
it('powinien zgłosić błąd dla wartości poza zakresem', () => {
//
});
it('powinien ograniczyć wartość do zakresu, jeśli transformacja włączona', () => {
//
});
});Przypadki użycia fabryk dekoratorów
Fabryki dekoratorów są szczególnie przydatne w następujących przypadkach:
- Frameworki i biblioteki - tworzenie konfigurowalnych dekoratorów dla użytkowników frameworka
- Aspekty przekrojowe - logowanie, walidacja, zabezpieczenia, które muszą być dostosowane do wielu przypadków
- Konfiguracja środowiskowa - dostosowanie zachowania dekoratorów do różnych środowisk (rozwój, produkcja)
- Zarządzanie zasobami - monitorowanie, śledzenie i kontrolowanie dostępu do zasobów
- Zbieranie metryk - konfigurowanie sposobu zbierania metryk na podstawie różnych parametrów
- Kontrola dostępu - tworzenie dekoratorów uprawnień dla różnych poziomów i ról
Podsumowanie
Fabryki dekoratorów w TypeScript są potężnym narzędziem, które pozwala na tworzenie elastycznych, konfigurowalnych i wielokrotnego użytku dekoratorów. Podobnie jak systemy w Parku Jurajskim muszą być dostosowane do różnych potrzeb i wymagań, ale zachowywać jednolite standardy bezpieczeństwa, fabryki dekoratorów umożliwiają tworzenie spójnych, ale dostosowanych do konkretnych przypadków użycia dekoratorów.
Dzięki fabrykom dekoratorów możemy:
- Poprawić ponowne wykorzystanie kodu - tworząc konfigurowalne szablony dekoratorów
- Zwiększyć czytelność - ukrywając złożoną logikę pod prostym, deklaratywnym interfejsem
- Zapewnić spójność - stosując te same wzorce i struktury w całej aplikacji
- Zwiększyć elastyczność - dostosowując dekoratory do różnych przypadków użycia
Fabryki dekoratorów to zaawansowana technika w TypeScripcie, która wymaga dobrego zrozumienia dekoratorów, ale oferuje ogromne korzyści w zakresie organizacji kodu, jego ponownego wykorzystania i czytelności. Gdy zostaną dobrze zaprojektowane, stają się niezwykle wartościowymi narzędziami w twoim arsenale programistycznym.
Kod do tej lekcji: index.ts
// Fabryki dekoratorow - Konfigurowalne systemy Parku Jurajskiego
// Fabryka dekoratorow = funkcja zwracajaca dekorator z parametrami
// === FABRYKA: Kontrola dostepu wg roli ===
function RequireRole(requiredRole: string) {
return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value;
descriptor.value = function (...args: any[]) {
const userRole = (this as any).currentUserRole || "guest";
if (userRole !== requiredRole && userRole !== "admin") {
console.error("[DOSTEP ZABRONIONY] " + propertyKey + " wymaga roli: " + requiredRole);
return null;
}
console.log("[AUTORYZACJA] " + userRole + " -> " + propertyKey + " OK");
return originalMethod.apply(this, args);
};
return descriptor;
};
}
// === FABRYKA: Limit czasu wykonania ===
function Timeout(maxMs: number) {
return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value;
descriptor.value = function (...args: any[]) {
const start = Date.now();
const result = originalMethod.apply(this, args);
const elapsed = Date.now() - start;
if (elapsed > maxMs) {
console.warn("[TIMEOUT] " + propertyKey + " trwalo " + elapsed + "ms (limit: " + maxMs + "ms)");
}
return result;
};
return descriptor;
};
}
// === FABRYKA: Ponawianie operacji ===
function Retry(attempts: number, delayLabel: string = "retry") {
return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value;
descriptor.value = function (...args: any[]) {
let lastError: Error | null = null;
for (let i = 1; i <= attempts; i++) {
try {
const result = originalMethod.apply(this, args);
if (i > 1) console.log("[" + delayLabel.toUpperCase() + "] Sukces po " + i + " probie");
return result;
} catch (error: any) {
lastError = error;
console.warn("[" + delayLabel.toUpperCase() + "] Proba " + i + "/" + attempts + " nieudana: " + error.message);
}
}
throw lastError;
};
return descriptor;
};
}
// === FABRYKA: Walidacja parametrow ===
function ValidateParams(validators: Record<number, (val: any) => boolean>) {
return function (target: any, propertyKey: string, descriptor: PropertyDescriptor) {
const originalMethod = descriptor.value;
descriptor.value = function (...args: any[]) {
for (const [indexStr, validator] of Object.entries(validators)) {
const index = Number(indexStr);
if (!validator(args[index])) {
throw new Error("Walidacja parametru #" + index + " nieudana w " + propertyKey);
}
}
return originalMethod.apply(this, args);
};
return descriptor;
};
}
// === KLASA Z FABRYKAMI DEKORATOROW ===
class ParkSecuritySystem {
currentUserRole: string = "admin";
private failCount: number = 0;
@RequireRole("admin")
@Timeout(100)
initiateLockdown(sector: string): string {
return "LOCKDOWN aktywowany w sektorze " + sector;
}
@RequireRole("scientist")
checkDNA(sampleId: string): string {
return "Analiza DNA probki " + sampleId + " zakonczona";
}
@Retry(3, "sensor")
readSensor(sensorId: string): number {
this.failCount++;
if (this.failCount % 3 !== 0) {
throw new Error("Sensor " + sensorId + " nie odpowiada");
}
return Math.floor(Math.random() * 100);
}
@ValidateParams({ 0: (v: any) => typeof v === "string" && v.length >= 3 })
registerDinosaur(name: string): string {
return "Zarejestrowano dinozaura: " + name;
}
}
// === TESTOWANIE ===
const security = new ParkSecuritySystem();
console.log("=== Fabryki dekoratorow ===\n");
// Test RequireRole
console.log(security.initiateLockdown("A1"));
security.currentUserRole = "guest";
security.checkDNA("DNA-001");
security.currentUserRole = "admin";
// Test Retry
console.log("\n=== Odczyt sensora (z ponowieniem) ===");
try {
const reading = security.readSensor("S-042");
console.log("Odczyt:", reading);
} catch (e: any) {
console.error("Ostateczny blad:", e.message);
}
// Test ValidateParams
console.log("\n=== Walidacja ===");
console.log(security.registerDinosaur("Rex"));
try {
security.registerDinosaur("AB"); // za krotka nazwa
} catch (e: any) {
console.error("Blad:", e.message);
}
// TODO: Stworz fabryke @Cache(ttlMs) z czasem wygasniecia
// TODO: Stworz fabryke @RateLimit(maxCalls, windowMs)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. Czym jest fabryka dekoratorów (decorator factory) w TypeScript?
2. Co się stanie, gdy w TypeScript zadeklarujesz dwa interfejsy o tej samej nazwie?
Zadania praktyczne w grze
- Edytor kodu
Stwórz dekorator Cache (zapamiętujący wyniki), Retry (ponawiający próby) i Deprecated (logujący ostrzeżenie) według instrukcji.
- Klikanie w kolejności
Kliknij w odpowiedniej kolejności: gdy klasa ma wiele dekoratorów (@A @B @C class X), w jakiej kolejności przebiegają etapy?
- Układanie w poziomie
Ułóż konfigurację w tsconfig.json włączającą starszy tryb dekoratorów z metadanymi (potrzebny np. w NestJS):