Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura
Architektura event-driven i systemy czasowe w JavaScript
W tej lekcji9
Po opanowaniu wzorców projektowych, zasad SOLID, programowania funkcyjnego i optymalizacji bundli, czas połączyć tę wiedzę w praktyce. W tym rozdziale zbudujemy system oparty na zdarzeniach (event-driven architecture) z symulacją czasu - wzorzec powszechnie stosowany w grach, symulacjach i systemach monitoringu.
Czym jest architektura event-driven?
Architektura event-driven to podejście, w którym przepływ programu jest sterowany przez zdarzenia - akcje użytkownika, sygnały z sensorów, upływ czasu czy komunikaty z innych systemów. Zamiast liniowego wykonywania kodu, system reaguje na zdarzenia w momencie ich wystąpienia.
// Tradycyjne podejście - liniowe
function checkPark() {
checkFences();
feedDinosaurs();
updateVisitors();
generateReport();
}
// Event-driven - reaktywne
const eventBus = new EventEmitter();
eventBus.on('fence:alarm', handleFenceAlarm);
eventBus.on('dinosaur:hungry', scheduleFeedingRun);
eventBus.on('visitor:entered', updateVisitorCount);
eventBus.on('hour:changed', generateHourlyReport);W podejściu event-driven każdy komponent działa niezależnie i reaguje tylko na zdarzenia, które go dotyczą. To prowadzi do luźnego powiązania (loose coupling) - celu, któremu służą też poznane wcześniej zasady SOLID, zwłaszcza zasada odwrócenia zależności.
Wzorzec EventEmitter
Sercem architektury event-driven jest EventEmitter - implementacja wzorca Observer, który poznaliśmy w pierwszej lekcji tego modułu.
class EventEmitter {
constructor() {
this.listeners = new Map();
}
on(event, callback) {
if (!this.listeners.has(event)) {
this.listeners.set(event, []);
}
this.listeners.get(event).push(callback);
return this; // Fluent interface
}
off(event, callback) {
if (!this.listeners.has(event)) return this;
const callbacks = this.listeners.get(event);
const index = callbacks.indexOf(callback);
if (index > -1) callbacks.splice(index, 1);
return this;
}
emit(event, ...args) {
if (!this.listeners.has(event)) return false;
// Kopia tablicy, bo once() usuwa listener w trakcie pętli
[...this.listeners.get(event)].forEach(callback => {
callback(...args);
});
return true;
}
once(event, callback) {
const wrapper = (...args) => {
this.off(event, wrapper); // najpierw wyrejestruj, potem wywołaj
callback(...args);
};
return this.on(event, wrapper);
}
}Metoda once to elegancki przykład wzorca Decorator - opakowuje oryginalny callback w wrapper, który automatycznie się wyrejestrowuje po pierwszym wywołaniu.
Symulacja czasu - cykl dzień/noc
W systemach symulacyjnych czas jest kluczowym elementem. W Parku Jurajskim cykl dzień/noc wpływa na zachowanie dinozaurów, harmonogram karmienia, godziny odwiedzin i protokoły bezpieczeństwa.
class TimeSimulation extends EventEmitter {
constructor() {
super();
this.currentHour = 6; // Start o 6:00
this.day = 1;
this.scheduledEvents = [];
this.isRunning = false;
}
advanceHour() {
this.currentHour++;
if (this.currentHour >= 24) {
this.currentHour = 0;
this.day++;
this.emit('day:changed', this.day);
}
this.emit('hour:changed', this.currentHour, this.day);
// Sprawdź zaplanowane zdarzenia
this.checkScheduledEvents();
// Emituj zdarzenie tylko przy zmianie pory dnia
const timeOfDay = this.getTimeOfDay();
if (timeOfDay !== this.timeOfDay) {
this.timeOfDay = timeOfDay;
this.emit('timeOfDay:changed', timeOfDay);
}
}
getTimeOfDay() {
if (this.currentHour >= 6 && this.currentHour < 12) return 'rano';
if (this.currentHour >= 12 && this.currentHour < 18) return 'dzien';
if (this.currentHour >= 18 && this.currentHour < 22) return 'wieczor';
return 'noc';
}
scheduleEvent(hour, callback, options = {}) {
const event = {
hour,
callback,
recurring: options.recurring || false,
label: options.label || 'unnamed'
};
this.scheduledEvents.push(event);
return event;
}
checkScheduledEvents() {
this.scheduledEvents = this.scheduledEvents.filter(event => {
if (event.hour === this.currentHour) {
event.callback(this.currentHour, this.day);
return event.recurring; // Zachowaj tylko cykliczne
}
return true;
});
}
}Zwróć uwagę, jak klasa TimeSimulation dziedziczy po EventEmitter - to zastosowanie zasady Open/Closed z SOLID. Możemy rozszerzać zachowanie symulacji przez dodawanie nowych listenerów, bez modyfikacji samej klasy.
Planowanie zdarzeń cyklicznych
W realnym systemie wiele zdarzeń powtarza się cyklicznie - karmienie dinozaurów, patrole bezpieczeństwa, raporty statusu.
const sim = new TimeSimulation();
// Karmienie mięsożerców - codziennie o 7:00 i 17:00
sim.scheduleEvent(7, (hour, day) => {
console.log(`Dzień ${day}, ${hour}:00 - Karmienie mięsożerców`);
}, { recurring: true, label: 'karmienie-miesozerce' });
sim.scheduleEvent(17, (hour, day) => {
console.log(`Dzień ${day}, ${hour}:00 - Drugie karmienie mięsożerców`);
}, { recurring: true, label: 'karmienie-miesozerce-2' });
// Patrole bezpieczeństwa - co godzinę w nocy (22:00-5:00)
for (const h of [22, 23, 0, 1, 2, 3, 4, 5]) {
sim.scheduleEvent(h, (hour, day) => {
console.log(`Dzień ${day}, ${hour}:00 - Patrol nocny`);
}, { recurring: true, label: `patrol-${h}` });
}
// Raport dzienny - o 8:00
sim.scheduleEvent(8, (hour, day) => {
console.log(`Dzień ${day} - Generowanie raportu dziennego`);
}, { recurring: true, label: 'raport-dzienny' });Reakcja na pory dnia
Architektura event-driven pozwala różnym podsystemom reagować niezależnie na tę samą zmianę:
// System oświetlenia
sim.on('timeOfDay:changed', (timeOfDay) => {
const lightingProfiles = {
rano: { brightness: 70, color: 'warm-white' },
dzien: { brightness: 100, color: 'daylight' },
wieczor: { brightness: 40, color: 'amber' },
noc: { brightness: 10, color: 'red' } // Czerwone, by nie płoszyć dinozaurów
};
const profile = lightingProfiles[timeOfDay];
console.log(`Oświetlenie: ${profile.brightness}% (${profile.color})`);
});
// System bezpieczeństwa
sim.on('timeOfDay:changed', (timeOfDay) => {
if (timeOfDay === 'noc') {
console.log('Aktywacja nocnych protokołów bezpieczeństwa');
console.log('Zwiększenie napięcia ogrodzeń o 20%');
console.log('Włączenie kamer termowizyjnych');
} else if (timeOfDay === 'rano') {
console.log('Dezaktywacja nocnych protokołów');
console.log('Przywrócenie standardowego napięcia ogrodzeń');
}
});
// System odwiedzających
sim.on('hour:changed', (hour) => {
if (hour === 9) console.log('Park otwarty dla odwiedzających');
if (hour === 18) console.log('Ostatnie wejście dla odwiedzających');
if (hour === 20) console.log('Park zamknięty - ewakuacja gości');
});Łączenie z programowaniem funkcyjnym
Architekturę event-driven można wzbogacić o techniki funkcyjne, które poznaliśmy wcześniej w module:
// Funkcje czyste do transformacji danych
const calculateFeedingAmount = (species, weight, hour) => {
const baseAmount = weight * 0.02; // 2% masy ciała
const timeMultiplier = hour < 12 ? 1.2 : 0.8; // Więcej rano
return Math.round(baseAmount * timeMultiplier);
};
// Kompozycja funkcji do przetwarzania zdarzeń
const pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);
const processAlert = pipe(
(alert) => ({ ...alert, timestamp: Date.now() }),
(alert) => ({ ...alert, severity: alert.level > 7 ? 'critical' : 'warning' }),
(alert) => ({ ...alert, notified: true })
);
// Użycie z systemem zdarzeń
sim.on('alert:triggered', (rawAlert) => {
const processedAlert = processAlert(rawAlert);
console.log(`Alert [${processedAlert.severity}]: ${processedAlert.message}`);
});Zarządzanie stanem symulacji
Łączymy wzorzec zarządzania stanem (exercise_9_4) z systemem zdarzeń:
class SimulationState {
constructor(simulation) {
this.state = {
parkStatus: 'operational',
activeAlerts: 0,
dinosaursCount: 0,
visitorsCount: 0,
fencesStatus: 'all-operational'
};
this.history = [];
// Reaguj na zdarzenia symulacji
simulation.on('hour:changed', (hour) => {
this.updateState({ lastUpdate: hour });
});
simulation.on('alert:triggered', () => {
this.updateState({
activeAlerts: this.state.activeAlerts + 1
});
});
}
updateState(changes) {
// Niemutowalność - nowy obiekt stanu
const previousState = { ...this.state };
this.state = { ...this.state, ...changes };
this.history.push({
timestamp: Date.now(),
previous: previousState,
current: { ...this.state }
});
}
getState() {
return Object.freeze({ ...this.state });
}
}Testowanie systemów event-driven
Systemy oparte na zdarzeniach są łatwe do testowania dzięki luźnemu powiązaniu komponentów:
// Test symulacji czasu
function testTimeSimulation() {
const sim = new TimeSimulation();
const events = [];
sim.on('hour:changed', (hour) => events.push({ type: 'hour', hour }));
sim.on('day:changed', (day) => events.push({ type: 'day', day }));
// Symuluj 25 godzin (przejście przez cały dzień)
for (let i = 0; i < 25; i++) {
sim.advanceHour();
}
console.log(`Zarejestrowane zdarzenia: ${events.length}`);
console.log(`Zmiana dnia: ${events.filter(e => e.type === 'day').length}`);
console.log(`Aktualny dzień: ${sim.day}, godzina: ${sim.currentHour}`);
}
testTimeSimulation();Podsumowanie
Architektura event-driven łączy w sobie wiele wzorców i zasad, które poznałeś w tym module:
- Observer (exercise 9_1) - fundament systemu zdarzeń
- SOLID (exercise 9_2) - luźne powiązanie, otwartość na rozszerzenia
- Programowanie funkcyjne (exercise 9_3) - czyste funkcje do przetwarzania zdarzeń
- Zarządzanie stanem (exercise 9_4) - reaktywne aktualizacje stanu
- Optymalizacja (exercise 9_5-9_7) - mały bundle i podsystemy ładowane dopiero wtedy, gdy są potrzebne
To przygotowanie do projektu końcowego, w którym zintegrujesz wszystkie te elementy w kompletny system zarządzania Parkiem Jurajskim.
Kod do tej lekcji: index.js
// Symulacja czasu w parku
// Ćwiczenie: Zaimplementuj symulację cyklu dzień/noc
class TimeSimulation {
constructor() {
this.currentHour = 6;
this.day = 1;
this.events = [];
this.isRunning = false;
}
// Zaimplementuj metody:
// advanceHour() - przesuń czas o godzinę
// scheduleEvent(hour, callback) - zaplanuj zdarzenie
// getTimeOfDay() - zwróć porę dnia (rano/dzień/wieczór/noc)
advanceHour() {
// Twój kod tutaj
}
scheduleEvent(hour, callback) {
// Twój kod tutaj
}
getTimeOfDay() {
// Twój kod tutaj
}
}
const sim = new TimeSimulation();
console.log("Symulacja: Dzień", sim.day, "Godzina:", sim.currentHour);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 charakteryzuje się architektura event-driven?
2. Jakie trzy podstawowe metody powinien implementować EventEmitter?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy wywołania EventEmitter.on w odpowiedniej kolejności:
- Edytor kodu
W pliku index.js jest EventEmitter z lekcji o architekturze event-driven i klasa ParkTimeSystem, która symuluje godziny w parku. Uzupełnij luki: ___BLANK1___ to metoda tablicy, która w off() usuwa z listy jeden listener pod znalezionym indeksem, ___BLANK2___ to klasa, po której dziedziczy ParkTimeSystem, żeby mieć metody on, off i emit, a ___BLANK3___ to metoda tablicy, która z zaplanowanych wydarzeń wybiera tylko te na bieżącą godzinę. Co godzinę advanceHour() emituje 'hour:changed' z godziną i dniem, po północy najpierw 'day:changed' z numerem dnia, a każde wydarzenie zaplanowane metodą schedule(hour, name) na tę godzinę wywołuje 'event:triggered' z nazwą i godziną. start(intervalMs) uruchamia pętlę setInterval, a stop() ją zatrzymuje.
- Układanie w pionie
Uporządkuj etapy budowania systemu event-driven:
- Klikanie w kolejności
Ułóż poziomy testowania od najniższego do najwyższego.