Kurs JavaScript i TypeScript · Moduł 8: Zdarzenia i DOM

Delegacja wydarzeń (Event Delegation)

11 min czytania ·
W tej lekcji8

"W Parku Jurajskim," Ray Arnold wskazuje na centralny panel monitoringu, "nie instalujemy osobnego systemu alarmowego przy każdym dinozaurze. To byłoby kosztowne i nieefektywne. Zamiast tego mamy centralny system monitoringu sektorów, który obsługuje wszystkie zagrody w swoim obszarze."

Ray otwiera schemat systemu. "Event delegation działa na tej samej zasadzie. Zamiast przypisywać setki event listenerów do poszczególnych elementów, przypisujemy jeden listener do ich wspólnego rodzica. Ten rodzic 'deleguje' obsługę do właściwych elementów."

Czym jest event delegation?

Event delegation to technika wykorzystująca propagację wydarzeń (bubbling) do obsługi zdarzeń na wielu elementach przez jeden listener przypisany do ich wspólnego przodka. To jedna z najważniejszych i najwydajniejszych technik w JavaScript.

Problem: Wiele event listenerów

"Zobaczmy problem," mówi Ray, pokazując kod, w którym każda karta dinozaura dostaje własny listener w pętli forEach.

// NIEEFEKTYWNE - osobny listener dla każdej karty
const dinosaurCards = document.querySelectorAll('.dinosaur-card');

console.log(`Przypisuję listenery do ${dinosaurCards.length} kart dinozaurów`);

dinosaurCards.forEach((card, index) => {
  card.addEventListener('click', function() {
    const dinoId = this.dataset.dinoId;
    const dinoName = this.dataset.dinoName;

    console.log(`Kliknięto dinozaura: ${dinoName} (ID: ${dinoId})`);
    showDinosaurDetails(dinoId);
  });

  console.log(`Listener ${index + 1}/${dinosaurCards.length} dodany`);
});

// Problemy tego podejścia:
// 1. Jeśli mamy 100 kart = 100 listenerów w pamięci
// 2. Dynamicznie dodane karty NIE będą miały listenerów
// 3. Trzeba ręcznie usuwać listenery przy usuwaniu kart
// 4. Większe zużycie pamięci i wolniejsza strona

Działa, ale sto kart to sto listenerów, a karta dodana później zostaje głucha, bo pętla wykonała się raz.

Rozwiązanie: Event Delegation

"Teraz obserwuj," Ray pokazuje lepsze rozwiązanie: jeden listener na galerii sam ustala, w którą kartę trafiło kliknięcie.

// EFEKTYWNE - jeden listener na kontenerze
const dinosaurGallery = document.getElementById('dinosaur-gallery');

dinosaurGallery.addEventListener('click', function(event) {
  // Znajdź najbliższą kartę dinozaura (nawet jeśli kliknięto w dziecko karty)
  const card = event.target.closest('.dinosaur-card');

  // Jeśli nie kliknięto w kartę dinozaura, zignoruj
  if (!card) return;

  // Upewnij się, że karta jest dzieckiem naszej galerii
  if (!dinosaurGallery.contains(card)) return;

  const dinoId = card.dataset.dinoId;
  const dinoName = card.dataset.dinoName;

  console.log(`Kliknięto dinozaura: ${dinoName} (ID: ${dinoId})`);
  showDinosaurDetails(dinoId);
});

// Zalety tego podejścia:
// 1. Tylko JEDEN listener niezależnie od liczby kart
// 2. Automatycznie obsługuje dynamicznie dodane karty
// 3. Lepsze zarządzanie pamięcią
// 4. Łatwiejsze utrzymanie kodu

Kliknięcie w obrazek karty bąbelkuje aż do galerii: event.target to element, w który kliknięto, a event.currentTarget to element z listenerem, czyli galeria. Metoda closest() idzie od target w górę i zwraca pasującą kartę albo null, a contains() sprawdza, czy karta leży w galerii. Cała technika to cztery kroki: znajdź kontener, dodaj na nim listener, sprawdź event.target i wykonaj akcję dla pasującego elementu.

Praktyczny przykład - System kart dinozaurów

"Zbudujmy kompletny system," mówi Ray. Oto struktura karty i początek listenera, który rozpoznaje przyciski szczegółów i karmienia.

// HTML struktura:
// <div id="dino-gallery">
//   <div class="dinosaur-card" data-dino-id="1" data-dino-name="T-Rex">
//     <img src="trex.jpg" alt="T-Rex">
//     <h3>Tyrannosaurus Rex</h3>
//     <div class="card-actions">
//       <button class="view-btn">Szczegóły</button>
//       <button class="feed-btn">Nakarm</button>
//       <button class="favorite-btn">★</button>
//     </div>
//   </div>
//   ... więcej kart
// </div>

const gallery = document.getElementById('dino-gallery');

gallery.addEventListener('click', function(event) {
  const target = event.target;

  // Obsługa przycisku szczegółów
  if (target.classList.contains('view-btn')) {
    const card = target.closest('.dinosaur-card');
    const dinoId = card.dataset.dinoId;
    const dinoName = card.dataset.dinoName;

    console.log(`Otwieranie szczegółów dla: ${dinoName}`);
    openDinosaurModal(dinoId);
    return; // Zatrzymaj dalsze sprawdzanie
  }

  // Obsługa przycisku karmienia
  if (target.classList.contains('feed-btn')) {
    const card = target.closest('.dinosaur-card');
    const dinoId = card.dataset.dinoId;
    const dinoName = card.dataset.dinoName;

    console.log(`Rozpoczynam karmienie: ${dinoName}`);
    feedDinosaur(dinoId);
    return;
  }

Atrybut data-dino-id czytamy jako dataset.dinoId, bo myślniki zamieniają się na camelCase. Każda gałąź kończy się return, więc jedno kliknięcie uruchamia jedną akcję. Dalej ulubione i sama karta.

  // Obsługa przycisku ulubione
  if (target.classList.contains('favorite-btn')) {
    const card = target.closest('.dinosaur-card');
    const dinoId = card.dataset.dinoId;
    const dinoName = card.dataset.dinoName;

    // Toggle stanu ulubionego
    target.classList.toggle('active');

    if (target.classList.contains('active')) {
      console.log(`Dodano do ulubionych: ${dinoName}`);
      addToFavorites(dinoId);
      target.textContent = '★';
    } else {
      console.log(`Usunięto z ulubionych: ${dinoName}`);
      removeFromFavorites(dinoId);
      target.textContent = '☆';
    }
    return;
  }

  // Obsługa kliknięcia w samą kartę (ale nie w przyciski)
  const card = target.closest('.dinosaur-card');
  if (card && gallery.contains(card)) {
    const dinoId = card.dataset.dinoId;
    const dinoName = card.dataset.dinoName;

    console.log(`Kliknięto kartę: ${dinoName}`);
    highlightCard(card);
  }
});

Kartę sprawdzamy na końcu, inaczej kliknięcie w przycisk podświetlałoby ją przy okazji. Sprawdzenie classList.contains wystarcza, bo w przyciskach jest sam tekst. Ikona w środku przejęłaby kliknięcie i warunek by zawiódł. Na koniec pomocnicy.

function openDinosaurModal(dinoId) {
  console.log(`Ładowanie danych dinozaura ID: ${dinoId}`);
  // Logika otwierania modala
}

function feedDinosaur(dinoId) {
  console.log(`Aktywacja systemu karmienia dla dinozaura ID: ${dinoId}`);
  console.log('Sprawdzanie bezpieczeństwa...');
  console.log('Otwieranie podajnika...');
  console.log('Karmienie zakończone');
}

function addToFavorites(dinoId) {
  const favorites = JSON.parse(localStorage.getItem('favoriteDinosaurs') || '[]');
  if (!favorites.includes(dinoId)) {
    favorites.push(dinoId);
    localStorage.setItem('favoriteDinosaurs', JSON.stringify(favorites));
    console.log('Zapisano w ulubionych');
  }
}

function removeFromFavorites(dinoId) {
  let favorites = JSON.parse(localStorage.getItem('favoriteDinosaurs') || '[]');
  favorites = favorites.filter(id => id !== dinoId);
  localStorage.setItem('favoriteDinosaurs', JSON.stringify(favorites));
  console.log('Usunięto z ulubionych');
}

function highlightCard(card) {
  // Usuń highlight z innych kart
  document.querySelectorAll('.dinosaur-card.highlighted').forEach(c => {
    c.classList.remove('highlighted');
  });

  // Dodaj highlight do klikniętej karty
  card.classList.add('highlighted');
  console.log('Karta podświetlona');
}

Pomocnicy nie wiedzą nic o wydarzeniach. Zapis || '[]' ratuje pierwszą wizytę, gdy getItem() zwraca null.

Dynamiczne dodawanie elementów

"Największa zaleta delegacji," Ray dodaje nowe elementy do interfejsu, "to automatyczna obsługa dynamicznie dodawanych elementów."

const gallery = document.getElementById('dino-gallery');

// Event delegation - działa dla wszystkich kart, nawet przyszłych
gallery.addEventListener('click', function(event) {
  const card = event.target.closest('.dinosaur-card');
  if (!card) return;

  const dinoName = card.dataset.dinoName;
  console.log(`Kliknięto: ${dinoName}`);
});

// Funkcja dodająca nowe karty dynamicznie
function addNewDinosaur(dinosaur) {
  const newCard = document.createElement('div');
  newCard.className = 'dinosaur-card';
  newCard.dataset.dinoId = dinosaur.id;
  newCard.dataset.dinoName = dinosaur.name;

  newCard.innerHTML = `
    <img src="${dinosaur.image}" alt="${dinosaur.name}">
    <h3>${dinosaur.name}</h3>
    <p>${dinosaur.species}</p>
    <div class="card-actions">
      <button class="view-btn">Szczegóły</button>
      <button class="feed-btn">Nakarm</button>
      <button class="favorite-btn">☆</button>
    </div>
  `;

  gallery.appendChild(newCard);
  console.log(`Dodano nowego dinozaura: ${dinosaur.name}`);

  // NIE TRZEBA dodawać event listenerów!
  // Delegation automatycznie obsłuży nową kartę!
}

// Przykład użycia
setTimeout(() => {
  addNewDinosaur({
    id: '15',
    name: 'Spinosaurus',
    species: 'Spinosaurus aegyptiacus',
    image: 'spinosaurus.jpg'
  });

  // Nowa karta już działa z kliknięciami!
}, 3000);

W funkcji addNewDinosaur() nie ma ani jednego addEventListener, a Spinosaurus dodany po trzech sekundach od razu reaguje na kliknięcia, bo bąbelkują one do listenera czekającego na galerii od początku.

Zaawansowana delegacja - filtry i warunki

"Czasami," wyjaśnia Ray, "potrzebujemy bardziej precyzyjnej kontroli." Każdy przycisk panelu mówi przez data-action, co ma zrobić, a listener rozdziela zadania.

const parkDashboard = document.getElementById('park-dashboard');

parkDashboard.addEventListener('click', function(event) {
  const target = event.target;

  // Delegacja z atrybutem data-action
  const action = target.dataset.action;

  if (action) {
    console.log(`Akcja: ${action}`);

    switch(action) {
      case 'open-gate':
        handleOpenGate(target);
        break;

      case 'close-gate':
        handleCloseGate(target);
        break;

      case 'start-feeding':
        handleStartFeeding(target);
        break;

      case 'emergency-protocol':
        handleEmergencyProtocol(target);
        break;

      case 'view-stats':
        handleViewStats(target);
        break;

      default:
        console.log('Nieznana akcja:', action);
    }

    return;
  }

Nowa akcja to nowy case, a nie nowy listener. Gdy element nie ma akcji, listener sprawdza klasy metodą matches() i znaczniki przez tagName, który zwraca nazwę wielkimi literami, stąd 'A'.

  // Delegacja z klasami
  if (target.matches('.enclosure-zone')) {
    const enclosureId = target.dataset.enclosureId;
    console.log(`Kliknięto strefę zagrody: ${enclosureId}`);
    showEnclosureDetails(enclosureId);
    return;
  }

  // Delegacja z tagami
  if (target.tagName === 'A' && target.classList.contains('internal-link')) {
    event.preventDefault();
    const href = target.getAttribute('href');
    console.log(`Nawigacja wewnętrzna: ${href}`);
    navigateInternal(href);
    return;
  }
});

function handleOpenGate(button) {
  const gateId = button.dataset.gateId;
  const enclosureId = button.dataset.enclosureId;

  console.log(`Otwieranie bramy ${gateId} w zagrodzie ${enclosureId}`);
  console.log('Sprawdzanie statusu bezpieczeństwa...');
  console.log('Brama otwarta');
}

function handleCloseGate(button) {
  const gateId = button.dataset.gateId;
  console.log(`Zamykanie bramy ${gateId}`);
  console.log('Brama zamknięta i zabezpieczona');
}

function handleStartFeeding(button) {
  const enclosureId = button.dataset.enclosureId;
  const feedType = button.dataset.feedType;

  console.log(`Rozpoczęcie karmienia w zagrodzie ${enclosureId}`);
  console.log(`Typ pokarmu: ${feedType}`);
}

function handleEmergencyProtocol(button) {
  const protocolId = button.dataset.protocolId;

  console.log('ALARM! Aktywacja protokołu awaryjnego');
  console.log(`Protokół: ${protocolId}`);
  console.log('Zamykanie wszystkich bram...');
  console.log('Powiadamianie personelu...');
}

Wywołanie preventDefault() blokuje zwykłą nawigację linku, żeby panel przełączył widok sam. Każdy handler czyta dane przycisku przez dataset: znaczniki mówią, co zrobić, funkcje wiedzą jak.

Wydajność - porównanie

Ray pokazuje testy wydajności. "Liczby nie kłamią, ale każdy musi je zmierzyć u siebie." Funkcje console.time() i console.timeEnd() mierzą czas między wywołaniami z tą samą etykietą.

// Test 1: Bez delegation (osobne listenery)
console.time('Przypisywanie bez delegation');

const cards1 = document.querySelectorAll('.card');
cards1.forEach(card => {
  card.addEventListener('click', function() {
    console.log('Kliknięto');
  });
});

console.timeEnd('Przypisywanie bez delegation');
// Czas rośnie razem z liczbą kart: 100 kart = 100 wywołań addEventListener

// Test 2: Z delegation (jeden listener)
console.time('Przypisywanie z delegation');

const container = document.getElementById('container');
container.addEventListener('click', function(event) {
  if (event.target.matches('.card')) {
    console.log('Kliknięto');
  }
});

console.timeEnd('Przypisywanie z delegation');
// Jedno wywołanie addEventListener, niezależnie od liczby kart

// Zużycie pamięci:
// Bez delegation: osobny listener i osobna funkcja dla każdej karty
// Z delegation: jeden listener na kontenerze

console.log('Liczba listenerów dla 100 kart:');
console.log('Bez delegation: 100');
console.log('Z delegation: 1');
console.log('Dokładny czas i pamięć zmierz w DevTools swojej przeglądarki');

Celowo nie podajemy milisekund ani kilobajtów, bo zależą od przeglądarki i sprzętu. Pewne jest jedno: bez delegacji listenerów przybywa z każdą kartą, a z delegacją zostaje jeden.

matches() vs closest() - wybór metody

"Dwie najważniejsze metody w delegacji," wyjaśnia Ray. Obie przyjmują selektor CSS, ale patrzą w różne strony drzewa.

const container = document.getElementById('enclosure-list');

container.addEventListener('click', function(event) {
  const target = event.target;

  // matches() - sprawdza czy SAM element pasuje
  if (target.matches('.enclosure-item')) {
    console.log('Kliknięto BEZPOŚREDNIO w .enclosure-item');
    // Zadziała tylko jeśli kliknięto dokładnie w element z klasą
  }

  // closest() - szuka w górę do pierwszego pasującego
  const item = target.closest('.enclosure-item');
  if (item) {
    console.log('Kliknięto w .enclosure-item LUB jego dziecko');
    // Zadziała jeśli kliknięto w element lub jego dzieci
  }
});

// HTML:
// <div class="enclosure-item">
//   <h3>Zagroda T-Rex</h3>           ← matches() NIE, closest() TAK
//   <p>Status: Aktywna</p>           ← matches() NIE, closest() TAK
//   <button>Szczegóły</button>       ← matches() NIE, closest() TAK
// </div>                             ← matches() TAK, closest() TAK

// WNIOSEK: Używaj closest() dla delegation - jest bardziej elastyczne

Metoda matches() sprawdza tylko sam element, a closest() zaczyna od niego i idzie w górę. Dlatego polecam closest() jako domyślny wybór w delegacji.

Kompletny system zarządzania parkiem

"Połączmy wszystko w działający system," mówi Ray. Jeden listener na dashboardzie przekazuje kliknięcie kolejnym metodom klasy.

class JurassicParkManagementSystem {
  constructor() {
    this.selectedEnclosures = new Set();
    this.initialize();
  }

  initialize() {
    console.log('Inicjalizacja systemu zarządzania parkiem');
    this.setupDelegation();
  }

  setupDelegation() {
    // Jeden główny listener dla całego dashboardu
    const dashboard = document.getElementById('park-dashboard');

    dashboard.addEventListener('click', (event) => {
      this.handleDashboardClick(event);
    });

    console.log('System delegation aktywny');
  }

  handleDashboardClick(event) {
    const target = event.target;

    // Obsługa różnych typów kliknięć
    this.handleActionButton(target) ||
    this.handleTabNavigation(target) ||
    this.handleStatusIndicator(target) ||
    this.handleEnclosureSelection(target);
  }

Każda metoda zwraca true, gdy obsłużyła kliknięcie, a operator || zatrzymuje się na pierwszym true. Dlatego przyciski pytamy najpierw, a całą kartę na końcu, jak w galerii wyżej. Funkcja strzałkowa zachowuje this jako instancję klasy.

  handleEnclosureSelection(target) {
    const enclosure = target.closest('.enclosure-card');
    if (!enclosure) return false;

    const enclosureId = enclosure.dataset.enclosureId;
    const enclosureName = enclosure.dataset.enclosureName;

    console.log(`Wybrano zagrodę: ${enclosureName} (ID: ${enclosureId})`);

    // Toggle selekcji
    if (this.selectedEnclosures.has(enclosureId)) {
      this.selectedEnclosures.delete(enclosureId);
      enclosure.classList.remove('selected');
      console.log('Usunięto z selekcji');
    } else {
      this.selectedEnclosures.add(enclosureId);
      enclosure.classList.add('selected');
      console.log('Dodano do selekcji');
    }

    this.updateSelectionDisplay();
    return true;
  }

  handleActionButton(target) {
    const action = target.dataset.action;
    if (!action) return false;

    const enclosure = target.closest('.enclosure-card');
    const enclosureId = enclosure?.dataset.enclosureId;

    console.log(`Akcja: ${action} dla zagrody: ${enclosureId}`);

    const actions = {
      'feed': () => this.feedDinosaur(enclosureId),
      'clean': () => this.cleanEnclosure(enclosureId),
      'maintenance': () => this.scheduleMaintenance(enclosureId),
      'emergency': () => this.activateEmergency(enclosureId)
    };

    const handler = actions[action];
    if (handler) {
      handler();
      return true;
    }

    return false;
  }

Zbiór Set trzyma zaznaczenia bez duplikatów, obiekt actions zastępuje switch, a ?. chroni przed błędem, gdy przycisk nie leży w karcie. Zakładki i wskaźniki statusu działają tak samo.

  handleTabNavigation(target) {
    if (!target.classList.contains('tab-button')) return false;

    const tabName = target.dataset.tab;
    console.log(`Przełączanie na kartę: ${tabName}`);

    // Usuń active ze wszystkich tabów
    document.querySelectorAll('.tab-button').forEach(tab => {
      tab.classList.remove('active');
    });

    // Dodaj active do klikniętego
    target.classList.add('active');

    // Pokaż odpowiednią zawartość
    this.showTabContent(tabName);
    return true;
  }

  handleStatusIndicator(target) {
    if (!target.classList.contains('status-indicator')) return false;

    const enclosure = target.closest('.enclosure-card');
    const enclosureId = enclosure?.dataset.enclosureId;

    console.log(`Pokazywanie szczegółów statusu dla zagrody: ${enclosureId}`);
    this.showStatusDetails(enclosureId);
    return true;
  }

Żaden z tych elementów nie ma własnego listenera, bo ich kliknięcia docierają do dashboardu. Na końcu metody wykonawcze i start systemu.

  feedDinosaur(enclosureId) {
    console.log(`Karmienie dinozaura w zagrodzie: ${enclosureId}`);
  }

  cleanEnclosure(enclosureId) {
    console.log(`Czyszczenie zagrody: ${enclosureId}`);
  }

  scheduleMaintenance(enclosureId) {
    console.log(`Planowanie konserwacji dla zagrody: ${enclosureId}`);
  }

  activateEmergency(enclosureId) {
    console.log(`ALARM! Protokół awaryjny dla zagrody: ${enclosureId}`);
  }

  showTabContent(tabName) {
    console.log(`Ładowanie zawartości karty: ${tabName}`);
  }

  showStatusDetails(enclosureId) {
    console.log(`Szczegóły statusu zagrody: ${enclosureId}`);
  }

  updateSelectionDisplay() {
    const count = this.selectedEnclosures.size;
    const display = document.getElementById('selection-counter');

    if (display) {
      display.textContent = `Wybrano: ${count} zagród`;
    }

    console.log(`Aktualnie wybrane zagrody: ${Array.from(this.selectedEnclosures).join(', ')}`);
  }
}

// Inicjalizacja systemu
const parkSystem = new JurassicParkManagementSystem();

Jeden listener pilnuje całego dashboardu, niezależnie od liczby zagród.

Podsumowanie

"Event delegation," kończy Ray, "to nie tylko optymalizacja. To fundamentalna technika w nowoczesnym JavaScript. Jeden listener obsługujący tysiące elementów - to jak centralny system monitoringu obsługujący cały park. Wydajne, skalowalne i łatwe w utrzymaniu."

Kluczowe zasady:

  • Używaj closest() do znajdowania docelowych elementów
  • Sprawdzaj czy element jest dzieckiem kontenera z listenerem
  • Używaj data-atrybutów dla akcji i identyfikatorów
  • Pamiętaj o return po obsłużeniu wydarzenia
  • Delegacja działa automatycznie z dynamicznymi elementami
  • Oszczędza pamięć i poprawia wydajność

W piaskownicy listener dragstart wisi na całym dokumencie, więc dinozaury dokładane co dziesięć sekund od razu dają się przeciągać. Następna lekcja: wydarzenia myszy i klawiatury.

Pamiętaj: jeden czujnik w centrum kontroli sektora słyszy każdą zagrodę, także tę zbudowaną wczoraj.

Kod do tej lekcji: index.html
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Drag & Drop - Przenoszenie Dinozaurów</title>
    <style>
        body {
            font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
            background: linear-gradient(135deg, #2c3e50 0%, #34495e 100%);
            margin: 0;
            padding: 20px;
            color: white;
        }

        .container {
            max-width: 1200px;
            margin: 0 auto;
        }

        h1 {
            text-align: center;
            margin-bottom: 30px;
        }

        .instructions {
            background: rgba(52, 152, 219, 0.2);
            border: 1px solid #3498db;
            border-radius: 10px;
            padding: 20px;
            margin-bottom: 30px;
            text-align: center;
        }

        .enclosures-container {
            display: grid;
            grid-template-columns: 1fr 1fr;
            gap: 30px;
            margin-bottom: 30px;
        }

        .enclosure {
            background: rgba(0, 0, 0, 0.6);
            border: 3px dashed #7f8c8d;
            border-radius: 15px;
            padding: 20px;
            min-height: 300px;
            transition: all 0.3s ease;
        }

        .enclosure.drag-over {
            border-color: #3498db;
            background: rgba(52, 152, 219, 0.2);
            border-style: solid;
            transform: scale(1.02);
        }

        .enclosure h3 {
            text-align: center;
            margin-bottom: 20px;
            color: #ecf0f1;
        }

        .herbivore-enclosure {
            border-color: #27ae60;
        }

        .carnivore-enclosure {
            border-color: #e74c3c;
        }

        .herbivore-enclosure.drag-over {
            border-color: #2ecc71;
            background: rgba(46, 204, 113, 0.2);
        }

        .carnivore-enclosure.drag-over {
            border-color: #e74c3c;
            background: rgba(231, 76, 60, 0.2);
        }

        .dinosaur-card {
            background: linear-gradient(45deg, #34495e, #2c3e50);
            border-radius: 10px;
            padding: 15px;
            margin: 10px 0;
            cursor: grab;
            transition: all 0.3s ease;
            border: 2px solid transparent;
            user-select: none;
        }

        .dinosaur-card:hover {
            transform: translateY(-3px);
            box-shadow: 0 10px 25px rgba(0, 0, 0, 0.3);
        }

        .dinosaur-card.dragging {
            opacity: 0.5;
            transform: rotate(5deg);
            cursor: grabbing;
        }

        .dinosaur-card.herbivore {
            border-color: #27ae60;
        }

        .dinosaur-card.carnivore {
            border-color: #e74c3c;
        }

        .dino-header {
            display: flex;
            align-items: center;
            gap: 10px;
            margin-bottom: 10px;
        }

        .dino-emoji {
            font-size: 24px;
        }

        .dino-name {
            font-weight: bold;
            color: #ecf0f1;
        }

        .dino-info {
            font-size: 14px;
            color: #bdc3c7;
            margin: 5px 0;
        }

        .dino-diet {
            display: inline-block;
            padding: 3px 8px;
            border-radius: 12px;
            font-size: 12px;
            font-weight: bold;
        }

        .herbivore .dino-diet {
            background: #27ae60;
            color: white;
        }

        .carnivore .dino-diet {
            background: #e74c3c;
            color: white;
        }

        .drag-instructions {
            text-align: center;
            color: #bdc3c7;
            font-style: italic;
            margin: 20px 0;
        }

        .stats-panel {
            background: rgba(0, 0, 0, 0.8);
            border-radius: 10px;
            padding: 20px;
            margin-top: 30px;
        }

        .stats-grid {
            display: grid;
            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
            gap: 20px;
        }

        .stat-item {
            background: rgba(255, 255, 255, 0.1);
            padding: 15px;
            border-radius: 8px;
            text-align: center;
        }

        .stat-value {
            font-size: 24px;
            font-weight: bold;
            color: #3498db;
        }

        .stat-label {
            color: #bdc3c7;
            font-size: 14px;
            margin-top: 5px;
        }

        .danger-warning {
            background: #e74c3c;
            color: white;
            padding: 10px;
            border-radius: 8px;
            margin: 10px 0;
            text-align: center;
            font-weight: bold;
            display: none;
        }

        @media (max-width: 768px) {
            .enclosures-container {
                grid-template-columns: 1fr;
            }
        }
    </style>
</head>
<body>
    <div class="container">
        <h1>Przenoszenie Dinozaurów Między Zagrodami</h1>

        <div class="instructions">
            <strong>Zadanie:</strong> Przeciągnij dinozaury do odpowiednich zagród na podstawie ich diety.<br>
            <span style="color: #27ae60;">■</span> Roślinożercy → Zagroda bezpieczna |
            <span style="color: #e74c3c;">■</span> Mięsożercy → Zagroda wysokiego bezpieczeństwa
        </div>

        <div class="enclosures-container">
            <!-- Zagroda dla roślinożerców -->
            <div class="enclosure herbivore-enclosure" data-diet="herbivore" id="herbivore-enclosure">
                <h3>Zagroda Bezpieczna (Roślinożercy)</h3>
                <div class="drag-instructions">Przeciągnij tutaj roślinożerców</div>

                <!-- Początkowe dinozaury roślinożerne -->
                <div class="dinosaur-card herbivore" draggable="true" data-dino="triceratops" data-diet="herbivore">
                    <div class="dino-header">
                        <span class="dino-emoji">◆</span>
                        <span class="dino-name">Triceratops</span>
                    </div>
                    <div class="dino-info">Długość: 9m | Era: Kreda</div>
                    <span class="dino-diet">Roślinożerca</span>
                </div>

                <div class="dinosaur-card herbivore" draggable="true" data-dino="brachiosaurus" data-diet="herbivore">
                    <div class="dino-header">
                        <span class="dino-emoji">◆</span>
                        <span class="dino-name">Brachiosaurus</span>
                    </div>
                    <div class="dino-info">Długość: 23m | Era: Jura</div>
                    <span class="dino-diet">Roślinożerca</span>
                </div>
            </div>

            <!-- Zagroda dla mięsożerców -->
            <div class="enclosure carnivore-enclosure" data-diet="carnivore" id="carnivore-enclosure">
                <h3>Zagroda Wysokiego Bezpieczeństwa (Mięsożercy)</h3>
                <div class="drag-instructions">Przeciągnij tutaj mięsożerców</div>
                <div class="danger-warning" id="danger-warning">
                    UWAGA! Mieszanie mięsożerców i roślinożerców jest niebezpieczne!
                </div>

                <!-- Początkowe dinozaury mięsożerne -->
                <div class="dinosaur-card carnivore" draggable="true" data-dino="trex" data-diet="carnivore">
                    <div class="dino-header">
                        <span class="dino-emoji">◆</span>
                        <span class="dino-name">Tyrannosaurus Rex</span>
                    </div>
                    <div class="dino-info">Długość: 13m | Era: Kreda</div>
                    <span class="dino-diet">Mięsożerca</span>
                </div>

                <div class="dinosaur-card carnivore" draggable="true" data-dino="velociraptor" data-diet="carnivore">
                    <div class="dino-header">
                        <span class="dino-emoji">◆</span>
                        <span class="dino-name">Velociraptor</span>
                    </div>
                    <div class="dino-info">Długość: 2m | Era: Kreda</div>
                    <span class="dino-diet">Mięsożerca</span>
                </div>
            </div>
        </div>

        <!-- Panel statystyk -->
        <div class="stats-panel">
            <h3>Statystyki Zagród</h3>
            <div class="stats-grid">
                <div class="stat-item">
                    <div class="stat-value" id="herbivore-count">2</div>
                    <div class="stat-label">Roślinożercy</div>
                </div>
                <div class="stat-item">
                    <div class="stat-value" id="carnivore-count">2</div>
                    <div class="stat-label">Mięsożercy</div>
                </div>
                <div class="stat-item">
                    <div class="stat-value" id="total-moves">0</div>
                    <div class="stat-label">Całkowite przeniesienia</div>
                </div>
                <div class="stat-item">
                    <div class="stat-value" id="safety-status">OK</div>
                    <div class="stat-label">Status bezpieczeństwa</div>
                </div>
            </div>
        </div>
    </div>

    <script>
        let draggedElement = null;
        let totalMoves = 0;

        // Pobieramy referencje do elementów
        const herbivoreEnclosure = document.getElementById('herbivore-enclosure');
        const carnivoreEnclosure = document.getElementById('carnivore-enclosure');
        const dangerWarning = document.getElementById('danger-warning');
        const herbivoreCount = document.getElementById('herbivore-count');
        const carnivoreCount = document.getElementById('carnivore-count');
        const totalMovesCount = document.getElementById('total-moves');
        const safetyStatus = document.getElementById('safety-status');

        // Event listenery dla przeciąganego elementu
        document.addEventListener('dragstart', function(e) {
            if (e.target.classList.contains('dinosaur-card')) {
                draggedElement = e.target;
                e.target.classList.add('dragging');

                console.log(`Rozpoczęto przeciąganie: ${e.target.dataset.dino}`);

                // Ustawiamy dane dla transferu
                e.dataTransfer.setData('text/plain', e.target.dataset.dino);
                e.dataTransfer.effectAllowed = 'move';
            }
        });

        document.addEventListener('dragend', function(e) {
            if (e.target.classList.contains('dinosaur-card')) {
                e.target.classList.remove('dragging');
                draggedElement = null;
            }
        });

        // Event listenery dla obszarów drop
        document.querySelectorAll('.enclosure').forEach(enclosure => {
            enclosure.addEventListener('dragover', function(e) {
                e.preventDefault(); // Pozwalamy na drop
                e.dataTransfer.dropEffect = 'move';

                if (!this.classList.contains('drag-over')) {
                    this.classList.add('drag-over');
                }
            });

            enclosure.addEventListener('dragleave', function(e) {
                // Sprawdzamy czy opuszczamy rzeczywiście enclosure
                if (!this.contains(e.relatedTarget)) {
                    this.classList.remove('drag-over');
                }
            });

            enclosure.addEventListener('drop', function(e) {
                e.preventDefault();
                this.classList.remove('drag-over');

                if (draggedElement) {
                    const draggedDiet = draggedElement.dataset.diet;
                    const targetDiet = this.dataset.diet;
                    const dinoName = draggedElement.querySelector('.dino-name').textContent;

                    // Sprawdzamy czy dinozaur pasuje do zagrody
                    if (draggedDiet === targetDiet) {
                        // Przenosimy element
                        this.appendChild(draggedElement);
                        totalMoves++;

                        console.log(`${dinoName} przeniesiony do odpowiedniej zagrody!`);

                        // Animacja sukcesu
                        const movedCard = draggedElement; // dragend wyzeruje draggedElement przed upływem sekundy
                        movedCard.style.border = '2px solid #27ae60';
                        setTimeout(() => {
                            movedCard.style.border = '';
                        }, 1000);

                    } else {
                        // Nieprawidłowe przeniesienie
                        console.log(`BŁĄD: ${dinoName} nie może być w tej zagrodzie!`);

                        // Animacja błędu
                        const refusedCard = draggedElement;
                        refusedCard.style.border = '2px solid #e74c3c';
                        refusedCard.style.background = 'rgba(231, 76, 60, 0.3)';

                        setTimeout(() => {
                            refusedCard.style.border = '';
                            refusedCard.style.background = '';
                        }, 1000);

                        // Pokazujemy ostrzeżenie
                        alert(`OSTRZEŻENIE!\n\n${dinoName} nie może być umieszczony w tej zagrodzie!\n${draggedDiet === 'carnivore' ? 'Mięsożercy' : 'Roślinożercy'} muszą być w odpowiedniej zagrodzie dla bezpieczeństwa parku.`);
                    }

                    updateStats();
                }
            });
        });

        // Funkcja aktualizacji statystyk
        function updateStats() {
            const herbivores = document.querySelectorAll('#herbivore-enclosure .dinosaur-card').length;
            const carnivores = document.querySelectorAll('#carnivore-enclosure .dinosaur-card').length;

            herbivoreCount.textContent = herbivores;
            carnivoreCount.textContent = carnivores;
            totalMovesCount.textContent = totalMoves;

            // Sprawdzamy bezpieczeństwo
            const herbivoreEnclosureHasCarnivores = document.querySelectorAll('#herbivore-enclosure .carnivore').length > 0;
            const carnivoreEnclosureHasHerbivores = document.querySelectorAll('#carnivore-enclosure .herbivore').length > 0;

            const isDangerous = herbivoreEnclosureHasCarnivores || carnivoreEnclosureHasHerbivores;

            if (isDangerous) {
                safetyStatus.textContent = '!';
                safetyStatus.style.color = '#e74c3c';
                dangerWarning.style.display = 'block';
            } else {
                safetyStatus.textContent = 'OK';
                safetyStatus.style.color = '#27ae60';
                dangerWarning.style.display = 'none';
            }

            // Sprawdzamy czy wszystkie dinozaury są w odpowiednich zagrodach
            const allInCorrectEnclosures = !isDangerous;
            if (allInCorrectEnclosures && totalMoves > 0) {
                setTimeout(() => {
                    alert('Gratulacje!\n\nWszystkie dinozaury są teraz w odpowiednich zagrodach.\nPark jest bezpieczny!');
                }, 500);
            }
        }

        // Dodajemy nowe dinozaury po kilku sekundach
        function addNewDinosaur() {
            const newDinos = [
                {
                    name: 'Stegosaurus',
                    emoji: '',
                    diet: 'herbivore',
                    length: '9m',
                    era: 'Jura'
                },
                {
                    name: 'Allosaurus',
                    emoji: '',
                    diet: 'carnivore',
                    length: '9m',
                    era: 'Jura'
                }
            ];

            const randomDino = newDinos[Math.floor(Math.random() * newDinos.length)];

            const newDinoCard = document.createElement('div');
            newDinoCard.className = `dinosaur-card ${randomDino.diet}`;
            newDinoCard.draggable = true;
            newDinoCard.dataset.dino = randomDino.name.toLowerCase();
            newDinoCard.dataset.diet = randomDino.diet;

            newDinoCard.innerHTML = `
                <div class="dino-header">
                    <span class="dino-emoji">${randomDino.emoji}</span>
                    <span class="dino-name">${randomDino.name}</span>
                </div>
                <div class="dino-info">Długość: ${randomDino.length} | Era: ${randomDino.era}</div>
                <span class="dino-diet">${randomDino.diet === 'herbivore' ? 'Roślinożerca' : 'Mięsożerca'}</span>
            `;

            // Dodajemy do nieprawidłowej zagrody dla wyzwania
            if (randomDino.diet === 'herbivore') {
                carnivoreEnclosure.appendChild(newDinoCard);
            } else {
                herbivoreEnclosure.appendChild(newDinoCard);
            }

            updateStats();

            console.log(`Dodano nowego dinozaura: ${randomDino.name}`);
        }

        // Dodajemy nowego dinozaura co 10 sekund
        setInterval(addNewDinosaur, 10000);

        // Początkowa aktualizacja statystyk
        updateStats();

        // Touch events dla urządzeń mobilnych (podstawowa obsługa)
        let touchItem = null;
        let touchOffset = { x: 0, y: 0 };

        document.addEventListener('touchstart', function(e) {
            if (e.target.classList.contains('dinosaur-card')) {
                touchItem = e.target;
                const touch = e.touches[0];
                const rect = touchItem.getBoundingClientRect();

                touchOffset.x = touch.clientX - rect.left;
                touchOffset.y = touch.clientY - rect.top;

                touchItem.style.position = 'fixed';
                touchItem.style.zIndex = '1000';
                touchItem.classList.add('dragging');

                e.preventDefault();
            }
        });

        document.addEventListener('touchmove', function(e) {
            if (touchItem) {
                const touch = e.touches[0];
                touchItem.style.left = (touch.clientX - touchOffset.x) + 'px';
                touchItem.style.top = (touch.clientY - touchOffset.y) + 'px';

                e.preventDefault();
            }
        });

        document.addEventListener('touchend', function(e) {
            if (touchItem) {
                const touch = e.changedTouches[0];
                const elementBelow = document.elementFromPoint(touch.clientX, touch.clientY);
                const enclosure = elementBelow ? elementBelow.closest('.enclosure') : null;

                if (enclosure) {
                    draggedElement = touchItem;

                    // Symulujemy drop event
                    const dropEvent = new Event('drop');
                    enclosure.dispatchEvent(dropEvent);
                }

                // Reset styles
                touchItem.style.position = '';
                touchItem.style.left = '';
                touchItem.style.top = '';
                touchItem.style.zIndex = '';
                touchItem.classList.remove('dragging');

                touchItem = null;
                draggedElement = null;
            }
        });
    </script>
</body>
</html>

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. 1. Jakie są główne zalety event delegation (delegacji wydarzeń)?

  2. 2. Jaka jest różnica między event.target a event.currentTarget?

Zadania praktyczne w grze

  • Edytor kodu

    W pliku index.html jest lista kart dinozaurów #dino-list i przycisk, który dodaje nową kartę po załadowaniu strony. Zastosuj delegację zdarzeń: w miejscu ___BLANK1___ wpisz zmienną kontenera, na którym ma wisieć jedyny listener click, a w miejscu ___BLANK2___ metodę, która od event.target szuka najbliższego elementu pasującego do selektora .dino-card. Kliknięcie karty (także jej środka i karty dodanej później) ma pokazać nazwę dinozaura w #selected-dino, a karta z rezerwy poza listą ma zostać bez reakcji.

  • Układanie w pionie

    Ułóż kroki konfiguracji event delegation:

  • Układanie w poziomie

    Ułóż elementy delegacji zdarzeń:

  1. PytanieQuiz: Event delegation
  2. PytanieEvent.target vs Event.currentTarget
  3. Zadanie z kodemĆwiczenie: Event delegation
  4. Ułóż w kolejnościKonfiguracja event delegacji
  5. Ułóż w kolejnościSkładnia event delegation

Przydatne artykuły