Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Breakpointy i krokowe wykonanie kodu
W tej lekcji8
W poprzednim ćwiczeniu poznaliśmy konsolę przeglądarki i jej funkcje do logowania informacji. Jednak nawet najlepsze komunikaty w konsoli mogą być niewystarczające, gdy mamy do czynienia ze skomplikowanymi błędami w systemie zarządzania Parkiem Jurajskim. Co jeśli funkcja validateDinosaurContainment() zwraca nieprawidłowy wynik, ale nie wiemy dlaczego? Co jeśli algorytm śledzenia zachowań drapieżników zawiera subtelny błąd?
W takich przypadkach potrzebujemy możliwości wstrzymania wykonania kodu w określonym miejscu i przeanalizowania stanu aplikacji. Tutaj z pomocą przychodzą breakpointy i krokowe wykonanie kodu - jedne z najpotężniejszych technik debugowania aplikacji JavaScript.
Czym są breakpointy?
Breakpoint (punkt wstrzymania) to znacznik umieszczony w kodzie, który mówi przeglądarce, aby zatrzymała wykonanie kodu, gdy dotrze do tego miejsca. Pozwala to na dokładne zbadanie stanu aplikacji w wybranym momencie - możemy sprawdzić wartości zmiennych, obejrzeć stos wywołań i wykonać kod krok po kroku.
Ustawianie breakpointów w przeglądarce
Istnieje kilka sposobów ustawiania breakpointów w przeglądarce:
1. Breakpointy w Panelu Sources/Debugger
Najprostszym sposobem jest skorzystanie z panelu Sources (Chrome) lub Debugger (Firefox):
- Otwórz narzędzia deweloperskie (<kbd>F12</kbd> lub <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>I</kbd>)
- Przejdź do zakładki "Sources" (Chrome) lub "Debugger" (Firefox)
- Znajdź i otwórz plik, w którym chcesz ustawić breakpoint
- Kliknij numer linii, w której chcesz zatrzymać wykonanie kodu
- W wybranym miejscu pojawi się niebieska strzałka lub znacznik, wskazując aktywny breakpoint
Na przykład, możemy chcieć zatrzymać wykonanie kodu w momencie, gdy sprawdzamy status ogrodzenia w Parku Jurajskim:
function checkFenceStatus(sectorId) {
const sector = getSector(sectorId); // Ustawiamy breakpoint w tej linii
if (!sector) {
throw new Error(`Nieznany sektor: ${sectorId}`);
}
const fenceStatus = sector.fence.getStatus();
if (fenceStatus !== 'active') {
triggerAlarm(sectorId, `Awaria ogrodzenia: ${fenceStatus}`);
}
return fenceStatus;
}Po ustawieniu breakpointa, gdy funkcja checkFenceStatus() zostanie wywołana, przeglądarka zatrzyma wykonanie kodu w tej linii, a my będziemy mogli sprawdzić wartość sectorId i inne dostępne zmienne.
2. Programowe breakpointy z instrukcją debugger
Czasami wygodniejsze jest umieszczenie breakpointu bezpośrednio w kodzie, używając instrukcji debugger:
function trackDinosaur(dinosaurId, location) {
const dinosaur = getDinosaurById(dinosaurId);
debugger; // Kod zatrzyma się tutaj, gdy funkcja zostanie wywołana
if (!dinosaur) {
console.error(`Nie znaleziono dinozaura o ID: ${dinosaurId}`);
return false;
}
updateDinosaurLocation(dinosaurId, location);
checkContainmentStatus(dinosaurId, location);
return true;
}Instrukcja debugger zostanie zignorowana, jeśli narzędzia deweloperskie nie są otwarte, ale gdy są aktywne, przeglądarka zatrzyma wykonanie kodu w tym miejscu.
3. Warunkowe breakpointy
Czasem chcemy zatrzymać wykonanie kodu tylko wtedy, gdy spełniony jest określony warunek. Na przykład, gdy śledzimy dinozaura o konkretnym ID lub gdy poziom zagrożenia przekracza określoną wartość:
Ustawianie w interfejsie przeglądarki
- Ustaw zwykły breakpoint, klikając numer linii
- Kliknij prawym przyciskiem myszy na breakpoint
- Wybierz opcję "Edit breakpoint" lub "Add condition"
- Wprowadź warunek, na przykład:
dinosaurId === 'TRX-01'lubdangerLevel > 8
Programowe warunkowe zatrzymanie
Możemy również użyć konstrukcji warunkowej z instrukcją debugger:
function monitorDinosaurBehavior(dinosaur) {
const behaviorPattern = analyzeBehavior(dinosaur);
const dangerLevel = assessThreatLevel(behaviorPattern);
// Zatrzymaj wykonanie tylko jeśli poziom zagrożenia jest wysoki
if (dangerLevel > 8) {
debugger; // Zatrzyma się tylko dla wysokiego poziomu zagrożenia
// Kod do obsługi niebezpiecznych zachowań
activateEmergencyProtocol(dinosaur.id, dangerLevel);
}
return {
dinosaurId: dinosaur.id,
behaviorPattern,
dangerLevel,
timestamp: new Date()
};
}Krokowe wykonanie kodu (Step Execution)
Gdy kod jest zatrzymany na breakpoincie, mamy kilka opcji krokowego wykonania, które pozwalają na kontrolowane przejście przez kod:
1. Step Over (Krok nad / F10)
Wykonuje aktualną linię kodu i zatrzymuje się na następnej linii w tej samej funkcji. Jeśli aktualna linia zawiera wywołanie funkcji, funkcja ta jest wykonywana w całości (nie zatrzymujemy się wewnątrz niej).
function monitorParkSystems() {
checkSecuritySystems(); // Step Over wykona całą tę funkcję...
checkDinosaurContainment(); // ...i zatrzyma się na tej linii
checkVisitorSafety();
}2. Step Into (Krok do / F11)
Wykonuje aktualną linię kodu, ale jeśli linia zawiera wywołanie funkcji, debugger "wchodzi" do tej funkcji i zatrzymuje się na jej pierwszej linii.
function monitorParkSystems() {
checkSecuritySystems(); // Step Into "wejdzie" do tej funkcji...
checkDinosaurContainment(); // ...zamiast przejść od razu tutaj
checkVisitorSafety();
}
function checkSecuritySystems() {
const fenceStatus = checkFences(); // ...i zatrzyma się tutaj
const cameraStatus = checkCameras();
const gateStatus = checkGates();
return { fenceStatus, cameraStatus, gateStatus };
}3. Step Out (Krok na zewnątrz / Shift+F11)
Wykonuje pozostałą część aktualnej funkcji i zatrzymuje się po wyjściu z funkcji, w miejscu jej wywołania.
function checkSecuritySystems() {
const fenceStatus = checkFences();
const cameraStatus = checkCameras(); // Jeśli jesteśmy tutaj...
const gateStatus = checkGates();
return { fenceStatus, cameraStatus, gateStatus };
}
function monitorParkSystems() {
checkSecuritySystems(); // ...Step Out wykona resztę funkcji i zatrzyma się tutaj
checkDinosaurContainment();
checkVisitorSafety();
}4. Continue (Kontynuuj / F8)
Wznawia wykonanie kodu aż do napotkania następnego breakpointa lub zakończenia skryptu.
Inspekcja zmiennych i stanu
Gdy kod jest zatrzymany na breakpoincie, możemy szczegółowo zbadać stan aplikacji:
1. Panel Scope/Variables
Jeden z najważniejszych paneli podczas debugowania - pokazuje wszystkie dostępne zmienne w aktualnym zasięgu (scope):
- Local - zmienne lokalne w aktualnej funkcji
- Closure - zmienne z domknięć (funkcji nadrzędnych)
- Global - zmienne globalne
- this - wartość
thisw aktualnym kontekście
Na przykład, gdy debugujemy funkcję monitorującą zachowanie dinozaurów:
function analyzeDinosaurBehavior(dinosaur, environmentalFactors) {
const { species, previousBehaviors, lastFeeding } = dinosaur;
const { weather, timeOfDay, nearbyDinosaurs } = environmentalFactors;
const timeSinceFeeding = Date.now() - lastFeeding;
const isHungry = timeSinceFeeding > getSpeciesFeedingThreshold(species);
debugger; // zatrzymaj się tutaj
// W tym momencie w panelu Scope zobaczymy:
// - Local: dinosaur, environmentalFactors, species, previousBehaviors, lastFeeding,
// weather, timeOfDay, nearbyDinosaurs, timeSinceFeeding, isHungry
// - Global: globalne obiekty i funkcje
const behaviorPrediction = predictBehavior(
species,
previousBehaviors,
isHungry,
weather,
timeOfDay,
nearbyDinosaurs
);
return {
dinosaurId: dinosaur.id,
prediction: behaviorPrediction,
riskLevel: assessRiskLevel(behaviorPrediction),
isHungry,
timestamp: new Date()
};
}2. Watch Expressions (Wyrażenia obserwowane)
Panel Watch pozwala na dodanie wyrażeń, które chcemy monitorować podczas debugowania. Jest to szczególnie przydatne dla złożonych wyrażeń lub wartości, które nie są bezpośrednio widoczne w panelu Scope:
// Możemy dodać wyrażenia obserwowane takie jak:
dinosaur.species === 'Velociraptor'
getDistanceFromFence(dinosaur.location)
isInDangerZone(dinosaur.location, restrictedSectors)3. Konsola w trybie debugowania
W trakcie zatrzymania na breakpoincie, konsola działa w kontekście aktualnej pozycji w kodzie. Możemy więc wykonywać wyrażenia, które mają dostęp do wszystkich zmiennych widocznych w bieżącym zasięgu:
// W konsoli możemy wpisać:
dinosaur.species
timeSinceFeeding / (1000 * 60 * 60) // Konwersja milisekund na godziny
nearbyDinosaurs.filter(d => d.species === 'Velociraptor')Jest to potężny sposób na interaktywne badanie stanu aplikacji i wykonywanie eksperymentów bez modyfikowania kodu.
Praktyczne techniki debugowania dla Parku Jurajskiego
1. Debugowanie asynchronicznego kodu
Systemy w Parku Jurajskim często wykorzystują asynchroniczne operacje - pobieranie danych z czujników, komunikacja z systemami bezpieczeństwa, etc. Debugowanie takiego kodu wymaga specjalnych technik:
async function monitorsEnvironmentalSensors() {
try {
console.log("Rozpoczęcie monitorowania czujników...");
// Asynchroniczne pobranie danych z czujników
const temperatureData = await fetchSensorData('temperature');
debugger; // Breakpoint zatrzyma się po otrzymaniu odpowiedzi
const humidityData = await fetchSensorData('humidity');
const windData = await fetchSensorData('wind');
// Analiza danych środowiskowych
const environmentalRisk = analyzeEnvironmentalRisk(
temperatureData,
humidityData,
windData
);
if (environmentalRisk.level === 'high') {
notifyParkManagement(
`Wykryto wysokie ryzyko środowiskowe: ${environmentalRisk.reason}`
);
}
return environmentalRisk;
} catch (error) {
console.error("Błąd monitorowania czujników:", error);
triggerBackupSystems();
return { level: 'unknown', reason: 'error' };
}
}W narzędziach deweloperskich nowoczesnych przeglądarek, breakpointy działają poprawnie z asynchronicznymi funkcjami - wykonanie zatrzyma się w punkcie debugger, nawet po operacjach await.
2. Zatrzymywanie na wyjątkach (Exceptions)
W złożonym systemie jakim jest Park Jurajski, błędy mogą pojawiać się w nieoczekiwanych miejscach. Zamiast ręcznie ustawiać breakpointy, możemy skonfigurować debugger, aby zatrzymywał się, gdy wystąpi wyjątek:
- Otwórz panel Sources/Debugger
- Znajdź sekcję "Breakpoints" (lub podobną)
- Zaznacz opcję "Pause on exceptions" (Zatrzymaj na wyjątkach)
- Opcjonalnie: zaznacz "Pause on caught exceptions" (Zatrzymaj na obsłużonych wyjątkach)
Teraz przeglądarka zatrzyma wykonanie kodu, gdy wystąpi jakikolwiek nieobsłużony wyjątek, co znacznie ułatwia identyfikację źródła problemów.
3. Mapowanie źródeł (Source Maps)
W produkcyjnych aplikacjach kod JavaScript jest często minifikowany i bundlowany, co utrudnia debugowanie. Mapowanie źródeł pozwala przeglądarkom pokazywać i debugować oryginalny kod źródłowy, nawet gdy wykonywany jest kod zminifikowany:
// webpack.config.js
module.exports = {
//
devtool: 'source-map', // Generuje mapy źródeł dla wszystkich plików
//
};Dla Parku Jurajskiego, gdzie bezpieczeństwo jest priorytetem, to kluczowa funkcja umożliwiająca szybkie debugowanie produkcyjnych problemów.
4. Logowanie punktów kontrolnych
Czasami, zwłaszcza w złożonych systemach, warto łączyć breakpointy z logowaniem, aby śledzić wykonanie kodu:
function monitorDinosaurMovement(dinosaurId) {
const dinosaur = getDinosaurById(dinosaurId);
console.log(`[Checkpoint 1] Rozpoczęcie monitorowania ${dinosaur.name}`);
if (!dinosaur.tracker.isActive) {
console.warn(`[Checkpoint 2A] Nieaktywny tracker dla ${dinosaur.name}`);
activateTracker(dinosaurId);
debugger; // Zatrzymaj się tylko, gdy tracker był nieaktywny
} else {
console.log(`[Checkpoint 2B] Tracker aktywny dla ${dinosaur.name}`);
}
const location = getLastKnownLocation(dinosaurId);
console.log(`[Checkpoint 3] Ostatnia lokalizacja: ${JSON.stringify(location)}`);
// Różne ścieżki bazujące na lokalizacji
if (isInRestrictedZone(location)) {
console.error(`[Checkpoint 4A] Dinozaur w strefie ograniczonej!`);
debugger; // Zawsze zatrzymaj się w przypadku naruszenia strefy
triggerContainmentProtocol(dinosaurId, location);
} else if (isApproachingFence(location)) {
console.warn(`[Checkpoint 4B] Dinozaur zbliża się do ogrodzenia`);
increaseSurveillance(dinosaurId);
} else {
console.log(`[Checkpoint 4C] Dinozaur w normalnej strefie`);
}
return {
dinosaurId,
location,
status: getCurrentStatus(dinosaurId)
};
}Taki wzorzec "checkpointów" pomaga śledzić przepływ wykonania i szybko identyfikować, która ścieżka kodu została wykonana, nawet gdy nie korzystamy aktywnie z debuggera.
Debugowanie w praktyce - analiza przypadku
Przeanalizujmy praktyczny przykład debugowania problemu w systemie monitorowania dinozaurów:
class DinosaurMonitoringSystem {
constructor() {
this.activeMonitors = new Map();
this.alertLevel = 'normal';
this.lastScanTime = null;
}
startMonitoring(dinosaurId) {
if (this.activeMonitors.has(dinosaurId)) {
console.log(`Monitoring dla dinozaura ${dinosaurId} już aktywny`);
return false;
}
const dinosaur = getDinosaurById(dinosaurId);
if (!dinosaur) {
console.error(`Nie znaleziono dinozaura o ID: ${dinosaurId}`);
return false;
}
// Tworzymy nowy monitor i dodajemy do aktywnych
const monitor = {
dinosaurId,
species: dinosaur.species,
startTime: Date.now(),
lastUpdate: Date.now(),
status: 'active',
readings: [],
checkInterval: getSpeciesCheckInterval(dinosaur.species)
};
this.activeMonitors.set(dinosaurId, monitor);
// Uruchamiamy interwał do regularnego sprawdzania
const intervalId = setInterval(() => {
this.checkDinosaurStatus(dinosaurId);
}, monitor.checkInterval);
monitor.intervalId = intervalId;
console.log(`Rozpoczęto monitoring dinozaura ${dinosaurId} (${dinosaur.species})`);
return true;
}
checkDinosaurStatus(dinosaurId) {
const monitor = this.activeMonitors.get(dinosaurId);
if (!monitor) {
console.error(`Brak aktywnego monitoringu dla dinozaura ${dinosaurId}`);
return null;
}
try {
// Pobieranie aktualnych danych
const dinosaur = getDinosaurById(dinosaurId);
const location = getLastKnownLocation(dinosaurId);
const vitalSigns = getVitalSigns(dinosaurId);
const behavior = analyzeBehavior(dinosaurId, location);
// BŁĄD: Nieprawidłowe obliczenie statusu zdrowia
const healthStatus = calculateHealthStatus(vitalSigns);
// BŁĄD: Nie sprawdzamy czy location istnieje!
const inContainment = isInContainmentZone(location.coordinates);
const reading = {
timestamp: Date.now(),
location,
vitalSigns,
behavior,
healthStatus,
inContainment
};
// Aktualizujemy monitor
monitor.readings.push(reading);
monitor.lastUpdate = reading.timestamp;
monitor.locationStatus = inContainment ? 'contained' : 'breach';
monitor.healthStatus = healthStatus;
// Sprawdzamy poziom zagrożenia
this.assessThreatLevel();
return reading;
} catch (error) {
console.error(`Błąd sprawdzania statusu dinozaura ${dinosaurId}:`, error);
monitor.lastError = {
timestamp: Date.now(),
message: error.message
};
return null;
}
}
stopMonitoring(dinosaurId) {
const monitor = this.activeMonitors.get(dinosaurId);
if (!monitor) {
console.warn(`Brak aktywnego monitoringu dla dinozaura ${dinosaurId}`);
return false;
}
// Zatrzymujemy interwał
clearInterval(monitor.intervalId);
// Usuwamy z aktywnych monitorów
this.activeMonitors.delete(dinosaurId);
console.log(`Zatrzymano monitoring dinozaura ${dinosaurId}`);
return true;
}
assessThreatLevel() {
// Logika oceny poziomu zagrożenia na podstawie wszystkich monitorów
let highestThreat = 'normal';
for (const [id, monitor] of this.activeMonitors.entries()) {
if (!monitor.locationStatus || monitor.locationStatus === 'breach') {
highestThreat = 'critical';
break;
}
if (monitor.healthStatus === 'agitated' && highestThreat !== 'critical') {
highestThreat = 'elevated';
}
}
// Aktualizujemy poziom alertu
if (highestThreat !== this.alertLevel) {
console.log(`Zmiana poziomu alertu: ${this.alertLevel} -> ${highestThreat}`);
this.alertLevel = highestThreat;
// Powiadomienie o zmianie poziomu alertu
notifyAlertLevelChange(this.alertLevel);
}
return this.alertLevel;
}
}Krok 1: Zidentyfikowanie problemu
Podczas testowania systemu monitorowania w Parku Jurajskim, odkrywamy, że system nieoczekiwanie zgłasza poziom alertu 'critical' dla niektórych dinozaurów, mimo że są one bezpiecznie w swoich wybiegach.
Krok 2: Ustawienie breakpointów
Ustawiamy breakpoint w metodzie checkDinosaurStatus, aby zbadać, co się dzieje:
checkDinosaurStatus(dinosaurId) {
const monitor = this.activeMonitors.get(dinosaurId);
if (!monitor) {
console.error(`Brak aktywnego monitoringu dla dinozaura ${dinosaurId}`);
return null;
}
debugger; // Ustawiamy breakpoint tutaj, aby zbadać wszystkie zmienne
try {
// ...reszta kodu
}
}Krok 3: Krokowe wykonanie i analiza
- Wykonujemy kod krok po kroku używając "Step Into" i "Step Over"
- Dochodzimy do linii, gdzie sprawdzany jest status lokalizacji:
// BŁĄD: Nie sprawdzamy czy location istnieje! const inContainment = isInContainmentZone(location.coordinates); - Sprawdzamy wartość zmiennej
locationw panelu Scope i widzimy, że jestnull - Zidentyfikowany problem: Funkcja
getLastKnownLocationczasem zwracanull, gdy nie może znaleźć lokalizacji, a kod nie sprawdza tego przypadku przed próbą dostępu dolocation.coordinates
Krok 4: Poprawa błędu
Modyfikujemy kod, aby obsługiwał przypadek, gdy location jest null:
// Bezpieczniejszy kod z weryfikacją
const location = getLastKnownLocation(dinosaurId);
const inContainment = location && location.coordinates
? isInContainmentZone(location.coordinates)
: false; // Jeśli nie znamy lokalizacji, zakładamy najgorszy scenariuszKrok 5: Weryfikacja rozwiązania
Po naprawieniu błędu, usuwamy breakpoint i testujemy system ponownie. Tym razem działa poprawnie, nie zgłaszając fałszywych alarmów.
Dobre praktyki debugowania
- Używaj znaczących nazw zmiennych - ułatwia to identyfikację zmiennych podczas debugowania
- Dodawaj dokumentację do funkcji - komentarze JSDoc pomagają zrozumieć cel funkcji i oczekiwane wartości
- Strukturyzuj kod logicznie - przejrzysty kod jest łatwiejszy do debugowania
- Używaj defensywnego programowania - sprawdzaj dane wejściowe i obsługuj przypadki brzegowe
- Twórz małe, dedykowane funkcje - łatwiej debugować funkcje o pojedynczej odpowiedzialności
- Używaj try-catch dla potencjalnie problematycznych części kodu - pomaga to zlokalizować źródło błędów
- Unikaj modyfikacji zmiennych debugowanych - może to zmienić zachowanie programu
Podsumowanie
Breakpointy i krokowe wykonanie kodu to nieocenione narzędzia w arsenale każdego programisty pracującego przy systemach Parku Jurajskiego. Pozwalają na:
- Zatrzymanie wykonania kodu w kluczowych momentach
- Zbadanie stanu aplikacji, wartości zmiennych i kontekstu wykonania
- Wykonanie kodu krok po kroku, aby zrozumieć jego przepływ
- Identyfikację źródła błędów, zwłaszcza w złożonych systemach
- Weryfikację poprawności działania funkcji i modułów
Pamiętaj, że w Parku Jurajskim, umiejętność szybkiego znalezienia i naprawienia błędów może być kwestią życia lub śmierci - zarówno kodu, jak i (w prawdziwym parku) odwiedzających!
Kod do tej lekcji: main.js
// Circular Dependencies - Park Jurajski
// Obsługa zależności cyklicznych w modułach
console.log("Circular Dependencies (Zależności Cykliczne)");
console.log("Jak radzić sobie z wzajemnymi zależnościami modułów\n");
// ===========================================
// PROBLEM: Zależności Cykliczne
// ===========================================
// === dinosaur-manager.js ===
class DinosaurManager {
constructor() {
this.dinosaurs = new Map();
}
addDinosaur(dinosaur) {
this.dinosaurs.set(dinosaur.id, dinosaur);
// Problem: potrzebujemy SecuritySystem, ale on również potrzebuje DinosaurManager
console.log(`Dodano dinozaura: ${dinosaur.name}`);
}
getDinosaur(id) {
return this.dinosaurs.get(id);
}
getAllDinosaurs() {
return Array.from(this.dinosaurs.values());
}
}
// === security-system.js ===
class SecuritySystem {
constructor(dinosaurManager) {
this.dinosaurManager = dinosaurManager;
this.securityLevel = 'GREEN';
}
checkSecurity() {
const dinosaurs = this.dinosaurManager.getAllDinosaurs();
const dangerousDinos = dinosaurs.filter(d => d.dangerLevel > 7);
if (dangerousDinos.length > 2) {
this.securityLevel = 'RED';
} else if (dangerousDinos.length > 0) {
this.securityLevel = 'YELLOW';
} else {
this.securityLevel = 'GREEN';
}
console.log(`Poziom bezpieczeństwa: ${this.securityLevel}`);
return this.securityLevel;
}
alertForDinosaur(dinosaur) {
if (dinosaur.dangerLevel > 7) {
console.log(`ALERT: ${dinosaur.name} jest niebezpieczny!`);
}
}
}
// === dinosaur.js ===
class Dinosaur {
constructor(name, species, dangerLevel, securitySystem) {
this.id = Math.random().toString(36).substr(2, 9);
this.name = name;
this.species = species;
this.dangerLevel = dangerLevel;
this.securitySystem = securitySystem;
}
roar() {
console.log(`${this.name}: ROAAR!`);
// Problem: potrzebujemy SecuritySystem, który potrzebuje DinosaurManager
if (this.securitySystem) {
this.securitySystem.alertForDinosaur(this);
}
}
}
// ===========================================
// ROZWIĄZANIE 1: Dependency Injection
// ===========================================
console.log("=== ROZWIĄZANIE 1: Dependency Injection ===\n");
const manager = new DinosaurManager();
const security = new SecuritySystem(manager);
const trex = new Dinosaur('Rexy', 'T-Rex', 9, security);
const raptor = new Dinosaur('Blue', 'Velociraptor', 7, security);
const brachi = new Dinosaur('Gentle Giant', 'Brachiosaurus', 2, security);
manager.addDinosaur(trex);
manager.addDinosaur(raptor);
manager.addDinosaur(brachi);
console.log("\nSprawdzanie bezpieczeństwa...");
security.checkSecurity();
console.log("\nTest dźwięków:");
trex.roar();
raptor.roar();
brachi.roar();
// ===========================================
// ROZWIĄZANIE 2: Event System
// ===========================================
console.log("\n=== ROZWIĄZANIE 2: Event System ===\n");
class EventBus {
constructor() {
this.listeners = {};
}
on(event, callback) {
if (!this.listeners[event]) {
this.listeners[event] = [];
}
this.listeners[event].push(callback);
}
emit(event, data) {
if (this.listeners[event]) {
this.listeners[event].forEach(callback => callback(data));
}
}
}
const eventBus = new EventBus();
class DinosaurManagerV2 {
constructor(eventBus) {
this.eventBus = eventBus;
this.dinosaurs = new Map();
// Nasłuchuj na wydarzenia
this.eventBus.on('dinosaur:added', (dino) => {
console.log(`Event: Dodano ${dino.name}`);
});
}
addDinosaur(dinosaur) {
this.dinosaurs.set(dinosaur.id, dinosaur);
this.eventBus.emit('dinosaur:added', dinosaur);
}
getAllDinosaurs() {
return Array.from(this.dinosaurs.values());
}
}
class SecuritySystemV2 {
constructor(eventBus) {
this.eventBus = eventBus;
this.securityLevel = 'GREEN';
// Nasłuchuj na wydarzenia
this.eventBus.on('dinosaur:added', (dino) => {
this.evaluateThreat(dino);
});
}
evaluateThreat(dinosaur) {
if (dinosaur.dangerLevel > 7) {
console.log(`Event Security: ${dinosaur.name} wymaga monitorowania`);
this.securityLevel = 'YELLOW';
}
}
}
const eventBusInstance = new EventBus();
const managerV2 = new DinosaurManagerV2(eventBusInstance);
const securityV2 = new SecuritySystemV2(eventBusInstance);
console.log("Dodawanie dinozaurów z event system:");
managerV2.addDinosaur({ id: '1', name: 'Rex Jr', dangerLevel: 8 });
managerV2.addDinosaur({ id: '2', name: 'Herbivore', dangerLevel: 2 });
// ===========================================
// ROZWIĄZANIE 3: Lazy Loading / Late Binding
// ===========================================
console.log("\n=== ROZWIĄZANIE 3: Lazy Loading ===\n");
class DinosaurManagerV3 {
constructor() {
this.dinosaurs = new Map();
this._securitySystem = null;
}
setSecuritySystem(security) {
this._securitySystem = security;
}
addDinosaur(dinosaur) {
this.dinosaurs.set(dinosaur.id, dinosaur);
console.log(`Lazy: Dodano ${dinosaur.name}`);
// Lazy evaluation - security jest dostępny dopiero teraz
if (this._securitySystem) {
this._securitySystem.checkSecurity();
}
}
getAllDinosaurs() {
return Array.from(this.dinosaurs.values());
}
}
class SecuritySystemV3 {
constructor() {
this._dinosaurManager = null;
}
setDinosaurManager(manager) {
this._dinosaurManager = manager;
}
checkSecurity() {
if (!this._dinosaurManager) {
console.log("DinosaurManager nie został jeszcze przypisany");
return;
}
const dinosaurs = this._dinosaurManager.getAllDinosaurs();
console.log(`Sprawdzam bezpieczeństwo dla ${dinosaurs.length} dinozaurów`);
}
}
const managerV3 = new DinosaurManagerV3();
const securityV3 = new SecuritySystemV3();
// Ustaw referencje po utworzeniu obu obiektów
managerV3.setSecuritySystem(securityV3);
securityV3.setDinosaurManager(managerV3);
managerV3.addDinosaur({ id: '1', name: 'Test Dino', dangerLevel: 5 });
console.log("\n=== NAJLEPSZE PRAKTYKI ===\n");
console.log("Dependency Injection:");
console.log(" - Przekazuj zależności przez konstruktor/parametry");
console.log(" - Testowalne i przewidywalne\n");
console.log("Event System:");
console.log(" - Luźne powiązanie między modułami");
console.log(" - Skalowalne dla wielu subskrybentów\n");
console.log("Lazy Loading:");
console.log(" - Opóźnione wiązanie zależności");
console.log(" - Dobre dla opcjonalnych zależności\n");
console.log("UNIKAJ:");
console.log(" - Bezpośrednich require/import tworzących cykle");
console.log(" - Globalnych zmiennych jako rozwiązania");
console.log(" - Tight coupling między modułami\n");
console.log("Demonstracja zakończona!");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj etapy debugowania kodu od początku do końca: