Kurs JavaScript i TypeScript · Moduł 8: Zdarzenia i DOM
Delegacja wydarzeń (Event Delegation)
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 stronaDział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 koduKliknię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 elastyczneMetoda 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
returnpo 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. Jakie są główne zalety event delegation (delegacji wydarzeń)?
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ń: