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

Wydarzenia i interakcje w JavaScript

6 min czytania ·
W tej lekcji3

"Witaj ponownie w Parku Jurajskim," pozdrawia Cię Ray Arnold, główny inżynier systemów. "Dzisiaj pokażę Ci, jak działa najbardziej krytyczny aspekt naszych systemów - interaktywność. Każdy system w parku, od bramek bezpieczeństwa po monitoring dinozaurów, musi reagować na różne sygnały w czasie rzeczywistym."

Ray prowadzi Cię do centralnego panelu kontrolnego, gdzie setki wskaźników migają i pulsują. "Zobacz," wskazuje na ekran, "te wszystkie systemy nasłuchują na wydarzenia - otwarcie bramy, ruch w zagrodzie, zmiana temperatury. W JavaScript działamy dokładnie tak samo."

Czym są wydarzenia w JavaScript?

Wydarzenia (events) to fundamentalny mechanizm komunikacji w przeglądarce. Każda interakcja użytkownika - kliknięcie, przesunięcie myszą, naciśnięcie klawisza - generuje wydarzenie, na które możemy zareagować.

// Podobnie jak sensor ruchu w zagrodzie dinozaurów
const motionSensor = document.getElementById('dino-enclosure');

motionSensor.addEventListener('click', function() {
  console.log('Wykryto aktywność w zagrodzie!');
  checkDinosaurStatus();
});

"W Parku Jurajskim," kontynuuje Ray, "mamy tysiące sensorów. Każdy wysyła sygnały do centrali. Gdybyśmy musieli stale sprawdzać każdy sensor, system by się zawalił. Zamiast tego, sensory wysyłają wydarzenia tylko wtedy, gdy coś się dzieje."

Model wydarzeń w przeglądarce

Przeglądarka implementuje tzw. Event-Driven Architecture - architekturę sterowaną wydarzeniami. To oznacza, że kod nie wykonuje się sekwencyjnie od góry do dołu, ale reaguje na wydarzenia zachodzące w systemie.

// Kod rejestruje listenery i czeka na wydarzenia
console.log('System aktywny - nasłuchuje...');

document.addEventListener('click', () => {
  console.log('Kliknięcie zarejestrowane!');
});

document.addEventListener('keydown', () => {
  console.log('Naciśnięto klawisz!');
});

// Program nie kończy się - czeka na wydarzenia
console.log('Wszystkie systemy gotowe');

Rodzaje wydarzeń

Ray pokazuje Ci listę na ekranie. "Mamy dziesiątki typów sensorów w parku. Podobnie JavaScript ma dziesiątki typów wydarzeń:"

Wydarzenia myszy:

  • click - kliknięcie (jak przycisk awaryjny)
  • dblclick - podwójne kliknięcie
  • mouseenter / mouseleave - najechanie/opuszczenie myszą
  • mousemove - ruch myszy (jak czujnik ruchu)
  • mousedown / mouseup - wciśnięcie/puszczenie przycisku myszy

Wydarzenia klawiatury:

  • keydown - wciśnięcie klawisza
  • keyup - puszczenie klawisza
  • keypress - przestarzałe, nie używaj (zamiast niego keydown albo input)

Wydarzenia formularzy:

  • submit - wysłanie formularza
  • change - zmiana wartości pola
  • input - wprowadzanie tekstu
  • focus / blur - aktywacja/dezaktywacja pola

Wydarzenia dokumentu:

  • DOMContentLoaded - DOM gotowy (jak system online)
  • load - wszystkie zasoby załadowane
  • scroll - przewijanie strony
  • resize - zmiana rozmiaru okna

Anatomia wydarzenia

"Każde wydarzenie niesie ze sobą informacje," wyjaśnia Ray, pokazując szczegółowy raport z sensora. "Podobnie każdy obiekt Event w JavaScript zawiera dane o tym, co się stało."

const enclosureMap = document.getElementById('park-map');

enclosureMap.addEventListener('click', function(event) {
  // Obiekt event zawiera szczegółowe informacje

  console.log('Typ wydarzenia:', event.type); // 'click'
  console.log('Element docelowy:', event.target); // kliknięty element
  console.log('Pozycja X:', event.clientX); // współrzędna X
  console.log('Pozycja Y:', event.clientY); // współrzędna Y
  console.log('Przycisk myszy:', event.button); // 0=lewy, 1=środkowy, 2=prawy
  console.log('Ctrl wciśnięty?', event.ctrlKey); // true/false
  console.log('Shift wciśnięty?', event.shiftKey); // true/false

  // Możemy użyć tych informacji do precyzyjnej reakcji
  if (event.ctrlKey) {
    selectMultipleDinosaurs(event.target);
  } else {
    selectSingleDinosaur(event.target);
  }
});

Dlaczego wydarzenia są ważne?

Ray wskazuje na wielki ekran pokazujący mapy wszystkich zagród. "Bez systemu wydarzeń, musielibyśmy co sekundę sprawdzać każdy sensor. To byłoby nieefektywne i obciążające. Wydarzenia pozwalają systemom reagować natychmiastowo i tylko wtedy, gdy to potrzebne."

W aplikacjach webowych wydarzenia umożliwiają:

  1. Interaktywność - reagowanie na działania użytkownika
  2. Wydajność - kod wykonuje się tylko gdy potrzebny
  3. Asynchroniczność - różne części aplikacji mogą działać niezależnie
  4. Modularność - różne komponenty mogą komunikować się przez wydarzenia

Pierwszy praktyczny przykład

"Zobaczmy to w akcji," mówi Ray, otwierając panel kodu. "Stwórzmy prosty system monitoringu zagrody."

// System monitoringu zagrody T-Rexa
const trexEnclosure = {
  temperature: 28,
  humidity: 65,
  feedingSchedule: '14:00',
  lastActivity: null,

  initialize() {
    // Rejestracja listenerów dla różnych systemów
    const tempSensor = document.getElementById('temp-sensor');
    const feedButton = document.getElementById('feed-button');
    const activityMonitor = document.getElementById('activity-monitor');

    // Monitoring temperatury
    tempSensor.addEventListener('change', (e) => {
      this.temperature = parseFloat(e.target.value);
      this.checkConditions();
    });

    // System karmienia
    feedButton.addEventListener('click', () => {
      this.feedDinosaur();
    });

    // Detekcja aktywności
    activityMonitor.addEventListener('motion', (e) => {
      this.lastActivity = new Date();
      this.logActivity(e.detail);
    });

    console.log('System monitoringu T-Rexa aktywny');
  },

  checkConditions() {
    if (this.temperature > 35) {
      this.triggerAlert('Temperatura zbyt wysoka!', 'warning');
    } else if (this.temperature < 20) {
      this.triggerAlert('Temperatura zbyt niska!', 'warning');
    } else {
      console.log('Warunki optymalne');
    }
  },

  feedDinosaur() {
    console.log('Rozpoczynam procedurę karmienia T-Rexa...');
    this.triggerAlert('Karmienie w toku', 'info');

    setTimeout(() => {
      console.log('Karmienie zakończone pomyślnie');
      this.triggerAlert('Karmienie zakończone', 'success');
    }, 3000);
  },

  logActivity(details) {
    console.log(`Aktywność zarejestrowana: ${details.type} o ${this.lastActivity.toLocaleTimeString()}`);
  },

  triggerAlert(message, level) {
    const alertEvent = new CustomEvent('parkAlert', {
      detail: { message, level, timestamp: new Date() }
    });
    document.dispatchEvent(alertEvent);
  }
};

// Inicjalizacja systemu
document.addEventListener('DOMContentLoaded', () => {
  trexEnclosure.initialize();
});

// Centralny system alertów
document.addEventListener('parkAlert', (e) => {
  const { message, level, timestamp } = e.detail;
  console.log(`[${timestamp.toLocaleTimeString()}] ${level.toUpperCase()}: ${message}`);
});

Dobre praktyki - zasady Raya Arnolda

"Przez lata pracy nad systemami Parku Jurajskiego," mówi Ray, "nauczyłem się kilku kluczowych zasad:"

1. Zawsze sprawdzaj czy element istnieje

const emergencyButton = document.getElementById('emergency');

if (emergencyButton) {
  emergencyButton.addEventListener('click', evacuatePark);
} else {
  console.error('KRYTYCZNY BŁĄD: Nie znaleziono przycisku awaryjnego!');
}

2. Usuwaj listenery gdy nie są potrzebne

function setupTemporaryMonitoring() {
  const sensor = document.getElementById('temp-sensor');

  function handleReading(e) {
    console.log('Odczyt:', e.target.value);
  }

  sensor.addEventListener('change', handleReading);

  // Po 1 godzinie wyłącz monitoring
  setTimeout(() => {
    sensor.removeEventListener('change', handleReading);
    console.log('Monitoring zakończony');
  }, 3600000);
}

3. Używaj nazwanych funkcji dla czytelności

Nazwa funkcji od razu mówi, co robi listener, a gdy coś pójdzie nie tak, zobaczysz ją w stosie wywołań w narzędziach deweloperskich.

// Lepiej
function handleEmergencyClick(event) {
  console.log('Aktywacja protokołu awaryjnego');
  evacuatePark();
}

emergencyButton.addEventListener('click', handleEmergencyClick);

// Niż
emergencyButton.addEventListener('click', function(e) {
  console.log('Aktywacja protokołu awaryjnego');
  evacuatePark();
});

4. Grupuj podobne wydarzenia

class EnclosureMonitor {
  constructor(enclosureId) {
    this.enclosure = document.getElementById(enclosureId);
    this.initializeEvents();
  }

  initializeEvents() {
    // Wszystkie event listenery w jednym miejscu
    this.enclosure.addEventListener('click', (e) => this.handleClick(e));
    this.enclosure.addEventListener('mouseenter', (e) => this.handleMouseEnter(e));
    this.enclosure.addEventListener('mouseleave', (e) => this.handleMouseLeave(e));
  }

  handleClick(event) {
    console.log('Kliknięto zagrodę');
  }

  handleMouseEnter(event) {
    this.enclosure.classList.add('highlighted');
  }

  handleMouseLeave(event) {
    this.enclosure.classList.remove('highlighted');
  }
}

Podsumowanie

"Wydarzenia to rdzeń każdego interaktywnego systemu," podsumowuje Ray. "Bez nich nasze aplikacje byłyby statyczne i bezużyteczne - jak park bez systemów bezpieczeństwa."

Kluczowe koncepcje:

  • Wydarzenia są generowane przez przeglądarkę w odpowiedzi na działania użytkownika
  • addEventListener() pozwala nasłuchiwać na wydarzenia
  • Obiekt event zawiera szczegółowe informacje o wydarzeniu
  • Właściwe zarządzanie listenerami jest kluczowe dla wydajności

W następnych lekcjach zagłębimy się w zaawansowane techniki obsługi wydarzeń, poznamy propagację, delegację i własne wydarzenia.

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>Park Jurajski - Panel Alarmowy</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;
        }

        .emergency-panel {
            max-width: 400px;
            margin: 50px auto;
            background: rgba(0, 0, 0, 0.8);
            border-radius: 15px;
            padding: 30px;
            box-shadow: 0 10px 30px rgba(0, 0, 0, 0.5);
            border: 2px solid #e74c3c;
        }

        .emergency-button {
            width: 100%;
            height: 100px;
            background: linear-gradient(45deg, #e74c3c, #c0392b);
            border: none;
            border-radius: 10px;
            color: white;
            font-size: 24px;
            font-weight: bold;
            cursor: pointer;
            transition: all 0.3s ease;
            margin-bottom: 20px;
            box-shadow: 0 5px 15px rgba(231, 76, 60, 0.4);
        }

        .emergency-button:hover {
            transform: translateY(-2px);
            box-shadow: 0 10px 25px rgba(231, 76, 60, 0.6);
            background: linear-gradient(45deg, #c0392b, #a93226);
        }

        .emergency-button:active {
            transform: translateY(0);
            box-shadow: 0 5px 15px rgba(231, 76, 60, 0.4);
        }

        .status-display {
            background: rgba(255, 255, 255, 0.1);
            border-radius: 8px;
            padding: 15px;
            margin-top: 20px;
            border: 1px solid rgba(255, 255, 255, 0.2);
        }

        .alert-message {
            display: none;
            background: #e74c3c;
            color: white;
            padding: 15px;
            border-radius: 8px;
            margin-top: 15px;
            text-align: center;
            font-weight: bold;
            animation: pulse 1s infinite;
        }

        @keyframes pulse {
            0% { opacity: 1; }
            50% { opacity: 0.7; }
            100% { opacity: 1; }
        }

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

        .last-activation {
            color: #bdc3c7;
            font-size: 14px;
        }
    </style>
</head>
<body>
    <div class="emergency-panel">
        <h1>PANEL ALARMOWY T-REX</h1>
        <button id="emergency-button" class="emergency-button">
            AKTYWUJ ALARM AWARYJNY
        </button>

        <div class="status-display">
            <div>Status systemu: <span id="system-status">GOTOWY</span></div>
            <div class="last-activation">Ostatnia aktywacja: <span id="last-activation">NIGDY</span></div>
        </div>

        <div id="alert-message" class="alert-message">
            ALARM! T-REX UCIEKŁ Z WYBIEGU!
        </div>
    </div>

    <script>
        // Pobieramy referencje do elementów DOM
        const emergencyButton = document.getElementById('emergency-button');
        const systemStatus = document.getElementById('system-status');
        const lastActivation = document.getElementById('last-activation');
        const alertMessage = document.getElementById('alert-message');

        // Dodajemy event listener do przycisku
        emergencyButton.addEventListener('click', function() {
            // Wyświetlamy alert
            alert('ALARM AWARYJNY AKTYWOWANY!\n\nT-Rex uciekł z wybiegu!\nEwakuacja w toku...');

            // Aktualizujemy status systemu
            systemStatus.textContent = 'ALARM AKTYWNY';
            systemStatus.style.color = '#e74c3c';

            // Zapisujemy czas ostatniej aktywacji
            const now = new Date();
            lastActivation.textContent = now.toLocaleTimeString('pl-PL');

            // Pokazujemy komunikat alarmowy
            alertMessage.style.display = 'block';

            // Zmieniamy tekst przycisku
            emergencyButton.textContent = 'ALARM AKTYWNY';
            emergencyButton.style.background = 'linear-gradient(45deg, #27ae60, #2ecc71)';

            // Po 5 sekundach resetujemy system
            setTimeout(function() {
                systemStatus.textContent = 'GOTOWY';
                systemStatus.style.color = '#2ecc71';
                alertMessage.style.display = 'none';
                emergencyButton.textContent = 'AKTYWUJ ALARM AWARYJNY';
                emergencyButton.style.background = 'linear-gradient(45deg, #e74c3c, #c0392b)';
            }, 5000);
        });

        // Dodajemy obsługę najechania myszą
        emergencyButton.addEventListener('mouseenter', function() {
            console.log('Kursor nad przyciskiem awaryjnym - UWAGA!');
        });

        emergencyButton.addEventListener('mouseleave', function() {
            console.log('Kursor opuścił przycisk awaryjny');
        });
    </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. Która metoda jest główną metodą do obsługi wydarzeń w JavaScript?

  1. PytanieQuiz: Podstawy wydarzeń

Przydatne artykuły