Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Breakpointy i krokowe wykonanie kodu

12 min czytania ·
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):

  1. Otwórz narzędzia deweloperskie (<kbd>F12</kbd> lub <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>I</kbd>)
  2. Przejdź do zakładki "Sources" (Chrome) lub "Debugger" (Firefox)
  3. Znajdź i otwórz plik, w którym chcesz ustawić breakpoint
  4. Kliknij numer linii, w której chcesz zatrzymać wykonanie kodu
  5. 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

  1. Ustaw zwykły breakpoint, klikając numer linii
  2. Kliknij prawym przyciskiem myszy na breakpoint
  3. Wybierz opcję "Edit breakpoint" lub "Add condition"
  4. Wprowadź warunek, na przykład: dinosaurId === 'TRX-01' lub dangerLevel > 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ść this w 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:

  1. Otwórz panel Sources/Debugger
  2. Znajdź sekcję "Breakpoints" (lub podobną)
  3. Zaznacz opcję "Pause on exceptions" (Zatrzymaj na wyjątkach)
  4. 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

  1. Wykonujemy kod krok po kroku używając "Step Into" i "Step Over"
  2. Dochodzimy do linii, gdzie sprawdzany jest status lokalizacji:
    // BŁĄD: Nie sprawdzamy czy location istnieje!
    const inContainment = isInContainmentZone(location.coordinates);
  3. Sprawdzamy wartość zmiennej location w panelu Scope i widzimy, że jest null
  4. Zidentyfikowany problem: Funkcja getLastKnownLocation czasem zwraca null, gdy nie może znaleźć lokalizacji, a kod nie sprawdza tego przypadku przed próbą dostępu do location.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 scenariusz

Krok 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

  1. Używaj znaczących nazw zmiennych - ułatwia to identyfikację zmiennych podczas debugowania
  2. Dodawaj dokumentację do funkcji - komentarze JSDoc pomagają zrozumieć cel funkcji i oczekiwane wartości
  3. Strukturyzuj kod logicznie - przejrzysty kod jest łatwiejszy do debugowania
  4. Używaj defensywnego programowania - sprawdzaj dane wejściowe i obsługuj przypadki brzegowe
  5. Twórz małe, dedykowane funkcje - łatwiej debugować funkcje o pojedynczej odpowiedzialności
  6. Używaj try-catch dla potencjalnie problematycznych części kodu - pomaga to zlokalizować źródło błędów
  7. 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:

  1. Ułóż w kolejnościEtapy debugowania kodu

Przydatne artykuły