Kurs JavaScript i React · Moduł 3: Stan i zdarzenia

Propagacja zdarzeń i zaawansowane wzorce obsługi zdarzeń

6 min czytania ·
W tej lekcji7

Na pokładzie statku kosmicznego React, zdarzenia nie poruszają się w próżni - podróżują przez hierarchię komponentów, jak sygnał alarmowy, który rozchodzi się od czujnika w maszynowni aż do głównego centrum dowodzenia. Zrozumienie propagacji zdarzeń (event propagation) pozwala precyzyjnie kontrolować, który komponent reaguje na sygnał i kiedy.

Jak zdarzenia propagują się w React

W przeglądarkowym DOMie zdarzenia przechodzą przez trzy fazy:

  1. Capture (przechwytywanie) - zdarzenie schodzi od korzenia dokumentu w dół do elementu docelowego
  2. Target - zdarzenie dociera do elementu, na którym nastąpiło kliknięcie
  3. Bubbling (bąbelkowanie) - zdarzenie wraca w górę, od elementu docelowego do korzenia

React domyślnie obsługuje zdarzenia w fazie bubbling - czyli zdarzenie "bąbelkuje" od dziecka do rodzica. Wyobraź sobie to jak alarm na statku: czujnik dymu w kajucie (element docelowy) uruchamia się, a sygnał bąbelkuje w górę - najpierw słyszy go komendant pokładu, potem szef inżynierów, a na końcu kapitan statku.

function SpaceStation() {
  const handleStationClick = () => {
    console.log('3. Stacja kosmiczna: sygnał dotarł do centrum dowodzenia');
  };

  return (
    <div onClick={handleStationClick} style={{ padding: '40px', background: '#1a1a3e' }}>
      <h2>Stacja Kosmiczna</h2>
      <Deck />
    </div>
  );
}

function Deck() {
  const handleDeckClick = () => {
    console.log('2. Pokład: sygnał przechodzi przez pokład');
  };

  return (
    <div onClick={handleDeckClick} style={{ padding: '30px', background: '#2a2a5e' }}>
      <p>Pokład główny</p>
      <Cabin />
    </div>
  );
}

function Cabin() {
  const handleCabinClick = () => {
    console.log('1. Kajuta: czujnik aktywowany!');
  };

  return (
    <button onClick={handleCabinClick}>
      Czujnik w kajucie
    </button>
  );
}

Po kliknięciu przycisku "Czujnik w kajucie" w konsoli pojawi się:

  1. Kajuta: czujnik aktywowany!
  2. Pokład: sygnał przechodzi przez pokład
  3. Stacja kosmiczna: sygnał dotarł do centrum dowodzenia

Zdarzenie bąbelkuje od dziecka do rodzica - dokładnie odwrotnie niż mogłoby się wydawać!

Zatrzymywanie propagacji - stopPropagation()

Czasem chcesz, żeby sygnał nie wychodził poza dany moduł statku. Metoda e.stopPropagation() zatrzymuje bąbelkowanie:

function ControlPanel() {
  const handlePanelClick = () => {
    console.log('Panel: to się NIE wywoła');
  };

  return (
    <div onClick={handlePanelClick} style={{ padding: '20px' }}>
      <h3>Panel sterowania</h3>
      <EmergencyButton />
    </div>
  );
}

function EmergencyButton() {
  const handleEmergency = (e) => {
    e.stopPropagation(); // Zatrzymaj propagację!
    console.log('Przycisk awaryjny: sygnał przechwycony lokalnie');
  };

  return (
    <button onClick={handleEmergency}>
      Przycisk awaryjny
    </button>
  );
}

Po kliknięciu "Przycisk awaryjny" tylko handler handleEmergency zostanie wywołany - zdarzenie nie dotrze do rodzica ControlPanel.

Zapobieganie domyślnemu zachowaniu - preventDefault()

Oprócz stopPropagation() (zatrzymuje bąbelkowanie), istnieje e.preventDefault() - zapobiega domyślnemu zachowaniu przeglądarki. Te dwie metody robią zupełnie różne rzeczy:

MetodaDziałanie
e.stopPropagation()Zatrzymuje bąbelkowanie do elementów nadrzędnych
e.preventDefault()Blokuje domyślne zachowanie przeglądarki (np. przesłanie formularza)
function MissionForm() {
  const [missionName, setMissionName] = useState('');

  const handleSubmit = (e) => {
    e.preventDefault(); // Zapobiegaj przeładowaniu strony!
    console.log('Misja zgłoszona:', missionName);
  };

  return (
    <form onSubmit={handleSubmit}>
      <input
        value={missionName}
        onChange={(e) => setMissionName(e.target.value)}
        placeholder="Nazwa misji"
      />
      <button type="submit">Zgłoś misję</button>
    </form>
  );
}

Bez e.preventDefault() formularz spowodowałby przeładowanie strony - domyślne zachowanie przeglądarki dla elementu <form>.

Delegacja zdarzeń (Event Delegation)

Delegacja zdarzeń to wzorzec, w którym jeden handler na rodzicu obsługuje zdarzenia ze wszystkich dzieci. To jak jeden oficer na mostku obsługujący wszystkie sygnały z poszczególnych sektorów zamiast przydzielania osobnego oficera do każdego czujnika:

function CrewList() {
  const crew = [
    { id: 1, name: 'Kapitan Nova', role: 'Dowodzenie' },
    { id: 2, name: 'Inżynier Astro', role: 'Napęd warpowy' },
    { id: 3, name: 'Nawigator Ra', role: 'Nawigacja' },
    { id: 4, name: 'Medyk Luna', role: 'Oddział medyczny' },
  ];

  // Jeden handler na rodzicu zamiast osobnego na każdym elemencie
  const handleCrewClick = (e) => {
    const crewId = e.target.closest('[data-crew-id]')?.dataset.crewId;
    if (crewId) {
      const member = crew.find(c => c.id === Number(crewId));
      console.log('Wybrany członek załogi:', member.name);
    }
  };

  return (
    <ul onClick={handleCrewClick}>
      {crew.map(member => (
        <li key={member.id} data-crew-id={member.id}>
          {member.name} - {member.role}
        </li>
      ))}
    </ul>
  );
}

W czystym JavaScripcie delegacja oszczędza setki osobnych nasłuchiwaczy przy dużych listach. React robi to za ciebie: od wersji 17 podpina po jednym nasłuchiwaczu każdego typu zdarzenia do korzenia aplikacji, więc onClick na 100 elementach <li> nie tworzy 100 nasłuchiwaczy w DOM. W React delegacja przydaje się więc wtedy, gdy jeden handler ma rozpoznać kliknięty element (np. po atrybucie data-*), a nie dla wydajności.

Przekazywanie argumentów do handlerów

Częstym wzorcem jest przekazywanie dodatkowych danych do handlera zdarzenia. Możesz owinąć wywołanie funkcją strzałkową w JSX albo przygotować funkcję, która zwraca gotowy handler (currying):

function MissionSelector() {
  const missions = ['Apollo', 'Artemis', 'Voyager', 'Orion'];
  const [selected, setSelected] = useState(null);

  // Wzorzec: funkcja zwracająca handler
  const handleSelect = (missionName) => () => {
    setSelected(missionName);
    console.log('Wybrano misję:', missionName);
  };

  // Alternatywnie bez curryingu: const selectMission = (missionName) => setSelected(missionName);
  // i w JSX: onClick={() => selectMission(mission)}

  return (
    <div>
      <h3>Wybierz misję:</h3>
      {missions.map(mission => (
        <button key={mission} onClick={handleSelect(mission)}>
          {mission}
        </button>
      ))}
      {selected && <p>Aktywna misja: {selected}</p>}
    </div>
  );
}

Wzorzec const handleSelect = (arg) => () => {...} (currying) to inny zapis tego samego: handleSelect(mission) też tworzy nową funkcję dla każdego przycisku przy każdym renderze, tak jak onClick={() => selectMission(mission)}. Wybierz zapis, który jest dla ciebie czytelniejszy - tworzenie funkcji w renderze jest w React normalne i nie trzeba go unikać.

Obsługa wielu zdarzeń jednym handlerem

Gdy komponent obsługuje wiele powiązanych zdarzeń, możesz użyć jednego handlera z rozróżnieniem po event.target.name lub event.target.dataset:

function ShipControls() {
  const [systems, setSystems] = useState({
    engines: false,
    shields: false,
    weapons: false,
  });

  const handleToggle = (e) => {
    const systemName = e.target.name;
    setSystems(prev => ({
      ...prev,
      [systemName]: !prev[systemName]
    }));
  };

  return (
    <div>
      <h3>Systemy statku:</h3>
      {Object.entries(systems).map(([name, isActive]) => (
        <label key={name} style={{ display: 'block', margin: '8px 0' }}>
          <input
            type="checkbox"
            name={name}
            checked={isActive}
            onChange={handleToggle}
          />
          {name}: {isActive ? 'AKTYWNY' : 'WYŁĄCZONY'}
        </label>
      ))}
    </div>
  );
}

Dzięki [systemName]: !prev[systemName] (computed property name) jeden handler obsługuje wszystkie checkboxy. Atrybut name na inpucie identyfikuje, który system ma zostać przełączony.

Podsumowanie

Propagacja zdarzeń i zaawansowane wzorce obsługi zdarzeń to kluczowe umiejętności pilota statku React:

  1. Bąbelkowanie - zdarzenia propagują od dziecka do rodzica (domyślnie w React)
  2. stopPropagation() - zatrzymuje propagację do elementów nadrzędnych
  3. preventDefault() - blokuje domyślne zachowanie przeglądarki (np. submit formularza)
  4. Delegacja zdarzeń - jeden handler na rodzicu zamiast wielu na dzieciach
  5. Przekazywanie argumentów do handlerów - funkcja strzałkowa w JSX albo currying
  6. Computed property names - jeden handler dla wielu powiązanych elementów

Opanowanie tych technik pozwoli ci budować precyzyjne systemy interakcji, gdzie każdy sygnał na statku trafia dokładnie tam, gdzie powinien!

Kod do tej lekcji: App.jsx
import React, { useState } from 'react';

function EventLog({ logs }) {
  return (
    <div style={{
      background: '#0d1117', borderRadius: '8px', padding: '12px',
      maxHeight: '120px', overflowY: 'auto', fontFamily: 'monospace', fontSize: '12px'
    }}>
      <div style={{ color: '#8b949e', marginBottom: '4px' }}>Konsola zdarzeń:</div>
      {logs.length === 0 && <div style={{ color: '#484f58' }}>Kliknij elementy, aby zobaczyć propagację...</div>}
      {logs.map((log, i) => (
        <div key={i} style={{ color: log.color, padding: '2px 0' }}>
          {log.text}
        </div>
      ))}
    </div>
  );
}

function SpaceStation() {
  const [logs, setLogs] = useState([]);
  const [stopPropagation, setStopPropagation] = useState(false);

  const addLog = (text, color) => {
    setLogs(prev => [...prev, { text, color }]);
  };

  const handleStationClick = () => {
    addLog('3. Stacja kosmiczna: sygnał dotarł do centrum dowodzenia', '#f39c12');
  };

  const handleDeckClick = (e) => {
    addLog('2. Pokład główny: sygnał przechodzi przez pokład', '#3498db');
  };

  const handleCabinClick = (e) => {
    if (stopPropagation) {
      e.stopPropagation();
      addLog('1. Kajuta: sygnał ZATRZYMANY (stopPropagation)', '#e74c3c');
    } else {
      addLog('1. Kajuta: czujnik aktywowany!', '#2ecc71');
    }
  };

  const handleClear = (e) => {
    e.stopPropagation();
    setLogs([]);
  };

  const styles = {
    container: { background: '#0a0e1a', color: '#e0e8ff', fontFamily: 'sans-serif', padding: '20px', minHeight: '100vh' },
    title: { color: '#4fc3f7', fontSize: '18px', marginBottom: '16px', textAlign: 'center' },
    station: { background: '#1a1a3e', borderRadius: '12px', padding: '20px', border: '2px solid #4fc3f7', cursor: 'pointer' },
    deck: { background: '#2a2a5e', borderRadius: '8px', padding: '16px', marginTop: '12px', border: '1px solid #6c6cae', cursor: 'pointer' },
    cabin: {
      display: 'block', width: '100%', marginTop: '12px', padding: '12px',
      background: '#27ae60', color: 'white', border: 'none', borderRadius: '6px',
      fontSize: '14px', cursor: 'pointer', fontWeight: 'bold'
    },
    toggle: {
      display: 'flex', alignItems: 'center', gap: '8px',
      margin: '16px 0', padding: '10px', background: '#1a2035', borderRadius: '6px'
    },
    clearBtn: {
      background: '#333', color: '#aaa', border: '1px solid #555', borderRadius: '4px',
      padding: '4px 12px', cursor: 'pointer', fontSize: '12px', marginTop: '8px'
    }
  };

  return (
    <div style={styles.container}>
      <h2 style={styles.title}>Propagacja zdarzeń w React</h2>

      <label style={styles.toggle}>
        <input type="checkbox" checked={stopPropagation} onChange={() => setStopPropagation(prev => !prev)} />
        <span style={{ color: stopPropagation ? '#e74c3c' : '#aaa' }}>
          stopPropagation() {stopPropagation ? 'AKTYWNE' : 'wyłączone'}
        </span>
      </label>

      <div style={styles.station} onClick={handleStationClick}>
        <div style={{ color: '#f39c12', fontSize: '12px' }}>onClick: Stacja Kosmiczna</div>
        <div style={styles.deck} onClick={handleDeckClick}>
          <div style={{ color: '#3498db', fontSize: '12px' }}>onClick: Pokład główny</div>
          <button style={styles.cabin} onClick={handleCabinClick}>
            Kliknij: Czujnik w kajucie
          </button>
        </div>
      </div>

      <div style={{ marginTop: '16px' }}>
        <EventLog logs={logs} />
        <button style={styles.clearBtn} onClick={handleClear}>Wyczyść konsolę</button>
      </div>
    </div>
  );
}

export default function App() {
  return <SpaceStation />;
}

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. W jakiej kolejności wywołują się handlery onClick przy kliknięciu elementu zagnieżdżonego w React (domyślnie)?

  2. 2. Jaka jest różnica między e.stopPropagation() a e.preventDefault()?

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz 3 stany logiczne: [lifeSupport, setLifeSupport] = useState(true), [powerGrid, setPowerGrid] = useState(true) i [communication, setCommunication] = useState(false). Dla każdego systemu dodaj przycisk, który przełącza jego stan (prev => !prev), i wyświetl status, np. Podtrzymywanie życia: {lifeSupport ? 'ON' : 'OFF'}. Kolor statusu zależy od stanu: zielony dla ON, czerwony dla OFF.

  • Układanie w pionie

    Uporządkuj fazy propagacji zdarzenia w przeglądarce od początku do końca:

  • Układanie w poziomie

    Ułóż składnię zatrzymania propagacji zdarzenia w React:

  • Edytor kodu

    Stwórz komponent MissionProtocols i wyrenderuj go w App. W stanie trzymaj tablicę protokołów { id, text, done }. Kontrolowane pole tekstowe i przycisk Dodaj dodają nowy protokół (nowa tablica przez spread). Każdy protokół ma checkbox, który przełącza done (map), i przycisk Usuń, który usuwa tylko ten protokół (filter). Wykonane protokoły wyróżnij stylem, np. textDecoration: 'line-through'.

  1. PytaniePropagacja zdarzeń w React
  2. PytaniestopPropagation vs preventDefault
  3. Zadanie z kodemPraktyka: Toggle switch
  4. Ułóż w kolejnościFazy propagacji zdarzeń w DOM
  5. Ułóż w kolejnościZatrzymanie propagacji zdarzenia
  6. Zadanie z kodemPraktyka: Lista zadań (todo)

Przydatne artykuły