Kurs JavaScript i TypeScript · Moduł 9: Wzorce projektowe i architektura
Projekt końcowy: System zarządzania Parkiem Jurajskim
W tej lekcji8
Witaj w laboratorium genetycznym Parku Jurajskiego! Po długiej podróży przez świat JavaScript, czas na wyzwanie wieńczące ten moduł. Dr Henry Wu, główny genetyk parku, powierza Ci stworzenie kompleksowego systemu zarządzania, który będzie nadzorować wszystkie aspekty działania parku - od monitorowania dinozaurów po zarządzanie bezpieczeństwem odwiedzających.
Cel projektu
Twoim zadaniem jest stworzenie zaawansowanej aplikacji JavaScript, która zintegruje wszystkie poznane przez Ciebie technologie w jeden spójny system. To będzie Twój magnum opus - dowód na to, że opanowałeś sztukę programowania w JavaScript.
Wymagania funkcjonalne systemu
1. System zarządzania dinozaurami
Twój system musi umożliwiać:
// Przykład struktury danych dinozaura
const dinosaurSpecies = {
id: 'trex-001',
name: 'Tyrannosaurus Rex',
species: 'T-Rex',
genome: {
dnaSequence: '4A7B...9F2E', // Sekwencja DNA
modifications: ['enhanced-strength', 'reduced-aggression'],
purity: 0.92, // 92% oryginalne DNA
gapsFilled: ['amphibian-dna', 'bird-dna']
},
physicalTraits: {
height: 5.6, // metry
weight: 8500, // kg
length: 12.8, // metry
age: 4, // lata
healthStatus: 'excellent'
},
behavior: {
aggressionLevel: 7, // 1-10
intelligence: 8,
socialBehavior: 'territorial',
huntingPattern: 'ambush-predator'
},
habitat: {
enclosureId: 'sector-7',
temperature: { min: 18, max: 28, current: 24 },
humidity: { min: 60, max: 80, current: 72 },
terrainType: 'forest-plains'
},
status: 'active' // active, sedated, medical-care, quarantine
};2. System monitorowania bezpieczeństwa
// Struktura systemu bezpieczeństwa
const securitySystem = {
alerts: {
breach: false,
evacuation: false,
containmentFailure: false,
emergencyProtocol: false
},
sensors: [
{
id: 'fence-sensor-001',
type: 'perimeter',
location: 'sector-7-north',
status: 'operational',
lastReading: Date.now(),
voltage: 10000 // napięcie ogrodzenia w woltach
},
{
id: 'motion-detector-034',
type: 'motion',
location: 'visitor-center',
status: 'operational',
sensitivity: 'high',
detectedMovement: false
}
],
accessControl: {
keyCards: new Map(), // ID karty -> poziom dostępu
restrictedAreas: ['genetic-lab', 'control-room', 'medical-bay'],
emergencyOverride: false
}
};3. System zarządzania odwiedzającymi
// System zarządzania odwiedzającymi
class VisitorManagementSystem {
constructor() {
this.visitors = new Map();
this.tours = new Map();
this.emergencyContactList = [];
this.evacuationProcedures = [];
}
registerVisitor(visitorData) {
const visitor = {
id: this.generateVisitorId(),
personalData: {
name: visitorData.name,
age: visitorData.age,
emergencyContact: visitorData.emergencyContact,
medicalConditions: visitorData.medicalConditions || [],
insurancePolicy: visitorData.insurancePolicy
},
visit: {
arrivalTime: new Date(),
departureTime: null,
tourType: visitorData.tourType, // 'standard', 'vip', 'research'
groupId: visitorData.groupId,
currentLocation: 'entrance',
visitedAreas: ['entrance']
},
safety: {
waiverSigned: false,
briefingCompleted: false,
emergencyProtocolsExplained: false,
trackingDevice: null
}
};
this.visitors.set(visitor.id, visitor);
return visitor.id;
}
trackVisitorLocation(visitorId, newLocation) {
const visitor = this.visitors.get(visitorId);
if (visitor) {
visitor.visit.currentLocation = newLocation;
visitor.visit.visitedAreas.push(newLocation);
this.validateSafetyProtocols(visitor);
}
}
}4. System laboratorium genetycznego
// System laboratorium genetycznego
class GeneticLaboratory {
constructor() {
this.dnaLibrary = new Map();
this.activeExperiments = [];
this.incubators = [];
this.sequencingMachines = [];
}
analyzeDNA(sampleId, dnaSequence) {
const analysis = {
sampleId,
sequenceLength: dnaSequence.length,
gcContent: this.calculateGCContent(dnaSequence),
mutations: this.detectMutations(dnaSequence),
viability: this.assessViability(dnaSequence),
recommendedModifications: [],
timestamp: new Date()
};
return analysis;
}
createNewSpecimen(parentDNA, modifications = []) {
const baseGenome = this.reconstructGenome(parentDNA);
const modifiedGenome = this.applyModifications(baseGenome, modifications);
const specimen = {
id: this.generateSpecimenId(),
genome: modifiedGenome,
generation: this.getParentGeneration(parentDNA) + 1,
created: new Date(),
status: 'developing',
expectedHatchTime: this.calculateHatchTime(modifiedGenome),
parentSpecimens: [parentDNA.id]
};
return this.initiateIncubation(specimen);
}
}Wymagania techniczne
1. Architektura aplikacji
Twoja aplikacja musi wykorzystywać:
- Module Pattern lub ES6 Modules do organizacji kodu
- Observer Pattern do komunikacji między komponentami
- Factory Pattern do tworzenia obiektów dinozaurów i odwiedzających
- Singleton Pattern dla systemów krytycznych (bezpieczeństwo, główna baza danych)
// Przykład architektury modularnej
// modules/ParkCore.js
class ParkCore {
constructor() {
if (ParkCore.instance) {
return ParkCore.instance;
}
this.systems = {
security: new SecuritySystem(),
genetic: new GeneticLaboratory(),
visitors: new VisitorManagementSystem(),
dinosaurs: new DinosaurRegistry(),
weather: new WeatherMonitoring(),
power: new PowerGrid()
};
this.eventBus = new EventBus();
this.setupSystemCommunication();
ParkCore.instance = this;
}
setupSystemCommunication() {
// Komunikacja między systemami przez event bus
this.eventBus.subscribe('security.breach', (data) => {
this.systems.visitors.initiateEvacuation(data.location);
this.systems.dinosaurs.activateContainmentProtocol();
});
this.eventBus.subscribe('dinosaur.escaped', (data) => {
this.systems.security.raiseAlert('containment-failure', data);
this.systems.visitors.redirectToSafeZones(data.dangerRadius);
});
}
}2. Zarządzanie danymi
// System zarządzania danymi z localStorage i IndexedDB
class DataManager {
constructor() {
this.localDB = new LocalDatabase('park-data');
this.cache = new Map();
this.syncQueue = [];
}
async saveDinosaurData(dinosaur) {
try {
// Zapisz do cache
this.cache.set(dinosaur.id, dinosaur);
// Zapisz do localStorage jako backup
localStorage.setItem(`dino_${dinosaur.id}`, JSON.stringify(dinosaur));
// Zapisz do IndexedDB dla większych danych
await this.localDB.store('dinosaurs', dinosaur);
// Dodaj do kolejki synchronizacji z serwerem
this.queueForSync('dinosaurs', dinosaur.id, 'update');
} catch (error) {
console.error('Błąd zapisywania danych dinozaura:', error);
throw new DataError('Nie udało się zapisać danych dinozaura');
}
}
async loadParkState() {
try {
const [dinosaurs, visitors, security] = await Promise.all([
this.localDB.getAll('dinosaurs'),
this.localDB.getAll('visitors'),
this.localDB.get('security', 'current-state')
]);
return {
dinosaurs: dinosaurs || [],
visitors: visitors || [],
security: security || this.getDefaultSecurityState()
};
} catch (error) {
console.error('Błąd ładowania stanu parku:', error);
return this.getEmergencyFallbackState();
}
}
}3. Interfejs użytkownika
Twój system musi posiadać:
- Dashboard główny z przeglądem wszystkich systemów
- Panel dinozaurów z listą, szczegółami i możliwością zarządzania
- Monitor bezpieczeństwa z alertami i statusem systemów
- Panel odwiedzających z listą aktywnych wycieczek
- Laboratorium genetyczne z narzędziami do analizy DNA
- System raportowania z wykresami i statystykami
// Przykład interfejsu użytkownika
class ParkInterface {
constructor(parkCore) {
this.park = parkCore;
this.currentView = 'dashboard';
this.refreshInterval = null;
this.setupEventListeners();
}
render() {
const app = document.getElementById('park-app');
app.innerHTML = `
<header class="park-header">
<h1>Jurassic Park Management System</h1>
<div class="system-status">${this.renderSystemStatus()}</div>
</header>
<nav class="park-navigation">
${this.renderNavigation()}
</nav>
<main class="park-content">
${this.renderCurrentView()}
</main>
<aside class="alerts-panel">
${this.renderAlerts()}
</aside>
`;
this.bindEvents();
}
renderDinosaurPanel() {
const dinosaurs = this.park.systems.dinosaurs.getAll();
return `
<div class="dinosaur-panel">
<h2>Zarządzanie dinozaurami</h2>
<div class="dinosaur-grid">
${dinosaurs.map(dino => `
<div class="dinosaur-card" data-id="${dino.id}">
<div class="dino-header">
<h3>${dino.name}</h3>
<span class="status ${dino.status}">${dino.status}</span>
</div>
<div class="dino-stats">
<div class="stat">
<label>Wiek:</label>
<span>${dino.physicalTraits.age} lat</span>
</div>
<div class="stat">
<label>Zdrowie:</label>
<span>${dino.physicalTraits.healthStatus}</span>
</div>
<div class="stat">
<label>Lokalizacja:</label>
<span>${dino.habitat.enclosureId}</span>
</div>
</div>
<div class="dino-actions">
<button data-action="feed">Nakarm</button>
<button data-action="checkup">Kontrola</button>
<button data-action="relocate">Przenieś</button>
</div>
</div>
`).join('')}
</div>
<button class="add-dinosaur-btn" data-action="add-dinosaur">
+ Dodaj nowego dinozaura
</button>
</div>
`;
}
bindEvents() {
// Jeden listener na kontenerze (delegacja zdarzeń): w atrybucie onclick "this" wskazywałby przycisk, a nie ParkInterface
document.getElementById('park-app').onclick = (event) => {
const button = event.target.closest('[data-action]');
if (!button) return;
const id = button.closest('.dinosaur-card')?.dataset.id;
const actions = {
feed: () => this.feedDinosaur(id),
checkup: () => this.medicateCheckup(id),
relocate: () => this.relocateDinosaur(id),
'add-dinosaur': () => this.showAddDinosaurForm()
};
actions[button.dataset.action]?.();
};
}
}4. Obsługa sytuacji kryzysowych
// System zarządzania kryzysowego
class EmergencyResponseSystem {
constructor(parkCore) {
this.park = parkCore;
this.emergencyLevel = 0; // 0-5, gdzie 5 to najwyższy
this.activeProtocols = [];
this.evacuationRoutes = this.loadEvacuationRoutes();
}
handleEmergency(type, severity, location, additionalData = {}) {
const emergency = {
id: this.generateEmergencyId(),
type, // 'containment-breach', 'power-failure', 'weather-emergency', 'medical'
severity, // 1-5
location,
timestamp: new Date(),
status: 'active',
data: additionalData
};
// Automatyczne procedury w zależności od typu i wagi zagrożenia
switch (type) {
case 'containment-breach':
this.handleContainmentBreach(emergency);
break;
case 'power-failure':
this.handlePowerFailure(emergency);
break;
case 'weather-emergency':
this.handleWeatherEmergency(emergency);
break;
case 'medical':
this.handleMedicalEmergency(emergency);
break;
default:
this.handleGenericEmergency(emergency);
}
return emergency.id;
}
handleContainmentBreach(emergency) {
const { location, data } = emergency;
// 1. Natychmiastowe zamknięcie dotkniętego sektora
this.park.systems.security.lockdownSector(location);
// 2. Aktywacja protokołu ewakuacji dla odwiedzających w zagrożonej strefie
const dangerZone = this.calculateDangerZone(location, data.dinosaurType);
this.park.systems.visitors.evacuateZone(dangerZone);
// 3. Wysłanie zespołu ratunkowego
this.deployResponseTeam('containment', location, data);
// 4. Informowanie wszystkich systemów
this.park.eventBus.publish('emergency.containment-breach', {
location,
dangerZone,
estimatedContainmentTime: this.estimateContainmentTime(data.dinosaurType)
});
// 5. Automatyczne protokoły bezpieczeństwa
this.activateEmergencyProtocol('Code Red - Containment Breach');
}
}Funkcje zaawansowane
1. Symulacja czasu rzeczywistego
// System symulacji czasu i cykli życiowych
class TimeSimulation {
constructor() {
this.gameTime = new Date();
this.timeMultiplier = 1; // 1 = czas rzeczywisty, 60 = 1 minuta = 1 godzina
this.isRunning = false;
this.events = [];
}
start() {
this.isRunning = true;
this.simulationLoop();
}
simulationLoop() {
if (!this.isRunning) return;
// Aktualizuj czas symulacji
this.gameTime = new Date(this.gameTime.getTime() + (1000 * this.timeMultiplier));
// Sprawdź zaplanowane wydarzenia
this.processScheduledEvents();
// Symuluj naturalne procesy
this.simulateNaturalProcesses();
// Następna iteracja za sekundę
setTimeout(() => this.simulationLoop(), 1000);
}
simulateNaturalProcesses() {
// Starzenie się dinozaurów
this.ageDinosaurs();
// Zmiany pogody
this.updateWeather();
// Zużycie zasobów (energia, pożywienie)
this.consumeResources();
// Naturalne zachowania dinozaurów
this.simulateDinosaurBehavior();
}
}2. System AI dla dinozaurów
// Sztuczna inteligencja dinozaurów
class DinosaurAI {
constructor(dinosaur) {
this.dinosaur = dinosaur;
this.currentState = 'idle';
this.needs = {
hunger: 50,
thirst: 30,
social: 70,
territory: 80,
reproduction: 20
};
this.decisionTree = this.buildDecisionTree();
}
makeDecision() {
const context = this.gatherEnvironmentalData();
const urgentNeed = this.findMostUrgentNeed();
const decision = this.decisionTree.evaluate(urgentNeed, context);
return this.executeDecision(decision);
}
buildDecisionTree() {
return {
evaluate: (need, context) => {
if (need === 'hunger' && this.needs.hunger > 80) {
return this.findFood(context);
}
if (need === 'social' && this.dinosaur.behavior.socialBehavior === 'pack') {
return this.seekPackMembers(context);
}
if (need === 'territory' && context.intruders.length > 0) {
return this.defendTerritory(context.intruders);
}
return { action: 'wander', target: this.chooseRandomLocation() };
}
};
}
}Kryteria oceny projektu
Twój projekt będzie oceniany według następujących kryteriów:
1. Funkcjonalność (30%)
- Wszystkie wymagane systemy działają poprawnie
- Obsługa błędów i sytuacji wyjątkowych
- Intuicyjny interfejs użytkownika
- Responsywność aplikacji
2. Kod i architektura (25%)
- Czytelny, dobrze skomentowany kod
- Prawidłowe użycie wzorców projektowych
- Modularna struktura aplikacji
- Przestrzeganie dobrych praktyk JavaScript
3. Funkcje zaawansowane (20%)
- Implementacja systemu czasu rzeczywistego
- AI dla dinozaurów
- Zaawansowane zarządzanie danymi
- System raportowania i analityki
4. Kreatywność i innowacyjność (15%)
- Unikalne funkcje i rozwiązania
- Interaktywne elementy UI/UX
- Ciekawe rozszerzenia tematu dinozaurów
- Implementacja dodatkowych systemów
5. Testowanie i dokumentacja (10%)
- Testy jednostkowe kluczowych funkcji
- Dokumentacja API i architektury
- Instrukcja obsługi dla użytkowników
- Komentarze w kodzie
Dodatkowe wyzwania (punkty bonusowe)
1. System genetyczny z prawdziwą logiką DNA
Zaimplementuj rzeczywisty system analizy sekwencji DNA z:
- Algorytmami mutacji genetycznych
- Systemem krzyżowania DNA różnych gatunków
- Przewidywaniem cech fizycznych na podstawie genotypu
- Symulacją dziedziczenia cech przez pokolenia
2. Multiplayer i komunikacja w czasie rzeczywistym
Dodaj funkcjonalność wieloużytkownikową:
- WebSocket dla komunikacji w czasie rzeczywistym
- Wspólne zarządzanie parkiem przez wielu użytkowników
- Chat między zarządzającymi parkiem
- Synchronizacja stanów między klientami
3. Zaawansowane API i integracje
Połącz z zewnętrznymi serwisami:
- Prawdziwe dane pogodowe
- Geolokalizacja użytkowników
- System płatności dla biletów
- Integracja z kalendarzem rezerwacji
4. Machine Learning i predykcja
Dodaj elementy uczenia maszynowego:
- Przewidywanie zachowań dinozaurów
- Optymalizacja harmonogramów karmienia
- Analiza wzorców odwiedzających
- Predykcja awarii systemów
Rozpoczęcie projektu
Krok 1: Planowanie
- Narysuj diagram architektury systemu
- Określ główne moduły i ich odpowiedzialności
- Zaplanuj strukturę danych
- Stwórz listę funkcjonalności MVP (Minimum Viable Product)
Krok 2: Implementacja MVP
- Stwórz podstawową strukturę aplikacji
- Zaimplementuj główne klasy (ParkCore, DataManager)
- Dodaj podstawowy interfejs użytkownika
- Połącz moduły przez event bus
Krok 3: Rozszerzanie funkcjonalności
- Dodaj każdy system pojedynczo
- Testuj integrację między systemami
- Implementuj zaawansowane funkcje
- Optymalizuj wydajność
Krok 4: Finalizacja
- Dodaj obsługę błędów
- Napisz testy
- Stwórz dokumentację
- Przeprowadź testy końcowe
Wskazówki techniczne
Struktura plików
jurassic-park-system/
├── index.html
├── css/
│ ├── main.css
│ ├── dashboard.css
│ └── components.css
├── js/
│ ├── core/
│ │ ├── ParkCore.js
│ │ ├── EventBus.js
│ │ └── DataManager.js
│ ├── systems/
│ │ ├── SecuritySystem.js
│ │ ├── DinosaurRegistry.js
│ │ ├── VisitorManager.js
│ │ └── GeneticLab.js
│ ├── ui/
│ │ ├── Dashboard.js
│ │ ├── DinosaurPanel.js
│ │ └── SecurityMonitor.js
│ ├── utils/
│ │ ├── helpers.js
│ │ └── validators.js
│ └── app.js
├── data/
│ ├── dinosaurs.json
│ ├── species-data.json
│ └── default-config.json
└── tests/
├── core.test.js
├── systems.test.js
└── integration.test.jsPrzykład inicjalizacji aplikacji
// app.js - główny plik aplikacji
document.addEventListener('DOMContentLoaded', async () => {
try {
// Inicjalizacja systemu
const park = new ParkCore();
await park.initialize();
// Ładowanie danych
const dataManager = new DataManager();
const savedState = await dataManager.loadParkState();
if (savedState) {
await park.loadState(savedState);
} else {
await park.initializeDefaultState();
}
// Inicjalizacja interfejsu
const ui = new ParkInterface(park);
ui.render();
// Start symulacji
const simulation = new TimeSimulation(park);
simulation.start();
console.log('Jurassic Park Management System uruchomiony pomyślnie!');
} catch (error) {
console.error('Błąd inicjalizacji systemu:', error);
showErrorPage('Nie udało się uruchomić systemu zarządzania parkiem');
}
});To jest Twoje wielkie wyzwanie na koniec modułu, młody programisto! Czas pokazać, czego się nauczyłeś, i stworzyć coś naprawdę wyjątkowego. Dr Wu i całe laboratorium genetyczne liczą na Ciebie!
Powodzenia w budowie przyszłości Parku Jurajskiego!
Kod do tej lekcji: index.js
// System AI Dinozaurów
// Ćwiczenie: Zaimplementuj system potrzeb i zachowań
class DinosaurAI {
constructor(name, species) {
this.name = name;
this.species = species;
this.needs = { hunger: 50, energy: 80, social: 60 };
this.behavior = "idle";
}
// Zaimplementuj metody:
// updateNeeds() - zaktualizuj potrzeby (losowe zmiany)
// decideBehavior() - podejmij decyzję o zachowaniu na podstawie potrzeb
// getStatus() - zwróć status dinozaura
updateNeeds() {
// Twój kod tutaj
}
decideBehavior() {
// Twój kod tutaj
}
getStatus() {
// Twój kod tutaj
}
}
const rex = new DinosaurAI("Blue", "Velociraptor");
console.log("AI dinozaura:", rex.name, "Status:", rex.behavior);Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?