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

Obsługa zdarzeń

10 min czytania ·
W tej lekcji8

W kosmicznej podróży przez React, obsługa zdarzeń to jak system kontroli lotu, pozwalający na reagowanie na różne akcje użytkownika. Jest to kluczowy element tworzenia interaktywnych interfejsów, które odpowiadają na działania użytkownika, takie jak kliknięcia, wprowadzanie tekstu czy ruchy myszką.

Podstawy obsługi zdarzeń w React

W React, obsługa zdarzeń działa podobnie jak w standardowym HTML, ale z kilkoma istotnymi różnicami:

  1. Nazwy zdarzeń używają konwencji camelCase zamiast małych liter:

    • HTML: onclick, onmouseover
    • React: onClick, onMouseOver
  2. W JSX przekazujemy funkcję jako handler zdarzenia, a nie string:

    • HTML: <button onclick="handleClick()">Kliknij</button>
    • React: <button onClick={handleClick}>Kliknij</button>
  3. Aby zapobiec domyślnemu zachowaniu, musimy jawnie wywołać preventDefault:

    • HTML: <a href="#" onclick="return false">Kliknij</a>
    • React: <a href="#" onClick={(e) => e.preventDefault()}>Kliknij</a>

Reagowanie na działania użytkownika

Zdarzenia to sposób, w jaki komponenty React reagują na działania użytkownika. Przyjrzyjmy się podstawowym typom zdarzeń i jak je obsługiwać.

Obsługa kliknięć

Najprostszym i najczęściej używanym zdarzeniem jest onClick:

function LaunchButton() {
  const handleLaunch = () => {
    console.log('Rozpoczynamy odliczanie do startu!');
    // Logika startu rakiety...
  };

  return (
    <button
      className="launch-button"
      onClick={handleLaunch}
    >
      Rozpocznij odliczanie
    </button>
  );
}

Argumenty w handlerach zdarzeń

Każdy handler zdarzenia otrzymuje obiekt zdarzenia (event) jako pierwszy argument. Zawiera on informacje o zdarzeniu i oferuje metody takie jak preventDefault():

function NavigationLink() {
  const handleClick = (event) => {
    event.preventDefault(); // Zapobiega domyślnej akcji (np. przejściu do innej strony)
    console.log('Link kliknięty, ale strona się nie przeładowała');

    // Niestandardowa nawigacja lub inna logika...
  };

  return (
    <a
      href="/destination"
      onClick={handleClick}
    >
      Przejdź do celu podróży
    </a>
  );
}

Obiekt, który React przekazuje do handlera, to SyntheticEvent - opakowanie natywnego zdarzenia przeglądarki. Ma ten sam interfejs (target, preventDefault(), stopPropagation()) i działa tak samo w każdej przeglądarce, a oryginalne zdarzenie znajdziesz w event.nativeEvent. Kolejność jest więc taka: użytkownik klika, przeglądarka tworzy zdarzenie, React opakowuje je w SyntheticEvent i dopiero wtedy wywołuje twój handler.

Przekazywanie argumentów do handlerów zdarzeń

Czasami potrzebujemy przekazać dodatkowe argumenty do handlera zdarzenia. Możemy to zrobić na dwa sposoby:

1. Używając funkcji strzałkowej (arrow function)

function MissionControl({ missions }) {
  const selectMission = (missionId, event) => {
    console.log(`Wybrano misję o ID: ${missionId}`);
    console.log('Zdarzenie:', event);
    // Logika wyboru misji...
  };

  return (
    <div className="mission-control">
      <h2>Dostępne misje</h2>
      <ul>
        {missions.map(mission => (
          <li key={mission.id}>
            {mission.name}
            <button onClick={(e) => selectMission(mission.id, e)}>
              Wybierz
            </button>
          </li>
        ))}
      </ul>
    </div>
  );
}

2. Używając bind

function MissionControl({ missions }) {
  const selectMission = (missionId, event) => {
    console.log(`Wybrano misję o ID: ${missionId}`);
    // Logika wyboru misji...
  };

  return (
    <div className="mission-control">
      <h2>Dostępne misje</h2>
      <ul>
        {missions.map(mission => (
          <li key={mission.id}>
            {mission.name}
            <button onClick={selectMission.bind(null, mission.id)}>
              Wybierz
            </button>
          </li>
        ))}
      </ul>
    </div>
  );
}

Podejście z funkcją strzałkową jest bardziej powszechne i zazwyczaj czytelniejsze.

Popularne zdarzenia w React

React obsługuje szeroki zakres zdarzeń, które możemy podzielić na kilka kategorii:

Zdarzenia myszy

  • onClick - kliknięcie
  • onDoubleClick - podwójne kliknięcie
  • onMouseEnter - najechanie kursorem na element
  • onMouseLeave - wyjście kursorem poza element
  • onMouseMove - ruch kursora nad elementem

Zdarzenia formularzy

  • onChange - zmiana wartości elementu formularza
  • onSubmit - wysłanie formularza
  • onFocus - element otrzymuje focus
  • onBlur - element traci focus

Zdarzenia klawiatury

  • onKeyDown - wciśnięcie klawisza
  • onKeyPress - przestarzałe, zamiast niego używaj onKeyDown
  • onKeyUp - zwolnienie klawisza

Zdarzenia dotyku (dla urządzeń mobilnych)

  • onTouchStart - rozpoczęcie dotyku
  • onTouchMove - ruch podczas dotyku
  • onTouchEnd - zakończenie dotyku

Przykłady obsługi różnych zdarzeń

Zdarzenia myszy ze stanem

Stan zapamiętuje, czy kursor jest nad panelem i czy panel został kliknięty, a zdarzenia onMouseEnter, onMouseLeave i onClick tylko ten stan zmieniają:

function InteractivePanel() {
  const [isHovered, setIsHovered] = useState(false);
  const [isClicked, setIsClicked] = useState(false);

  return (
    <div
      className={`panel ${isHovered ? 'hovered' : ''} ${isClicked ? 'clicked' : ''}`}
      onMouseEnter={() => setIsHovered(true)}
      onMouseLeave={() => {
        setIsHovered(false);
        setIsClicked(false);
      }}
      onClick={() => setIsClicked(!isClicked)}
    >
      <h3>Panel interaktywny</h3>
      <p>
        {isHovered ? 'Kursor nad panelem' : 'Najedź na panel'}
        {isClicked ? ' - Panel aktywny' : ' - Kliknij, aby aktywować'}
      </p>
    </div>
  );
}

Zdarzenia klawiatury

Klawisze obsługujemy tak samo jak kliknięcia - przez onKeyDown na elemencie, a event.key mówi, który klawisz wciśnięto:

function SpaceshipControls() {
  const [position, setPosition] = useState({ x: 50, y: 50 });

  const handleKeyDown = (event) => {
    switch(event.key) {
      case 'ArrowUp':
        setPosition(prev => ({ ...prev, y: Math.max(0, prev.y - 5) }));
        break;
      case 'ArrowDown':
        setPosition(prev => ({ ...prev, y: Math.min(100, prev.y + 5) }));
        break;
      case 'ArrowLeft':
        setPosition(prev => ({ ...prev, x: Math.max(0, prev.x - 5) }));
        break;
      case 'ArrowRight':
        setPosition(prev => ({ ...prev, x: Math.min(100, prev.x + 5) }));
        break;
      default:
        return;
    }
  };

  return (
    <div className="spaceship-simulator" tabIndex={0} onKeyDown={handleKeyDown}>
      <h2>Symulator statku kosmicznego</h2>
      <p>Kliknij symulator i steruj statkiem strzałkami</p>

      <div className="universe" style={{ position: 'relative', width: '400px', height: '400px', background: 'black' }}>
        <div
          className="spaceship"
          style={{
            position: 'absolute',
            left: `${position.x}%`,
            top: `${position.y}%`,
            transform: 'translate(-50%, -50%)',
            width: '20px',
            height: '20px',
            background: 'red'
          }}
        ></div>
      </div>

      <div className="coordinates">
        <p>Pozycja X: {position.x}</p>
        <p>Pozycja Y: {position.y}</p>
      </div>
    </div>
  );
}

tabIndex={0} pozwala elementowi div przyjąć fokus, więc onKeyDown działa po kliknięciu w symulator. Nasłuch na całym dokumencie wymaga useEffect ze sprzątaniem - poznasz go w module o efektach.

Przekazywanie funkcji jako props

Często potrzebujemy przekazać funkcje obsługi zdarzeń z komponentu rodzica do komponentu potomnego. Jest to powszechna praktyka, która pozwala na komunikację między komponentami:

function MissionControl({ onLaunch, onAbort }) {
  const [countdown, setCountdown] = useState(10);
  const [isLaunching, setIsLaunching] = useState(false);
  // useRef przechowuje identyfikator timera między renderami (zmiana ref nie powoduje ponownego renderowania)
  const timerRef = useRef(null);

  const stopTimer = () => {
    clearInterval(timerRef.current);
    timerRef.current = null;
  };

  const startCountdown = () => {
    setIsLaunching(true);
    let secondsLeft = 10;
    setCountdown(secondsLeft);

    timerRef.current = setInterval(() => {
      secondsLeft -= 1;
      setCountdown(secondsLeft);
      if (secondsLeft === 0) {
        stopTimer();
        setIsLaunching(false);
        onLaunch(); // Wywołanie funkcji z props po zakończeniu odliczania (poza funkcją aktualizującą stan)
      }
    }, 1000);
  };

  const abortLaunch = () => {
    stopTimer(); // Najpierw zatrzymaj odliczanie
    setIsLaunching(false);
    setCountdown(10);
    onAbort(); // Wywołanie funkcji z props przy przerwaniu
  };

  return (
    <div className="mission-control">
      <h2>Centrum kontroli misji</h2>
      <div className="countdown">
        {isLaunching
          ? `Start za: ${countdown}`
          : 'Gotowy do startu'}
      </div>

      <div className="control-buttons">
        {!isLaunching ? (
          <button onClick={startCountdown}>Rozpocznij odliczanie</button>
        ) : (
          <button onClick={abortLaunch} className="abort">Przerwij start</button>
        )}
      </div>
    </div>
  );
}

// Użycie komponentu
function SpaceProgram() {
  const handleLaunch = () => {
    console.log('Rakieta wystartowała!');
    // Logika po starcie...
  };

  const handleAbort = () => {
    console.log('Start przerwany!');
    // Logika po przerwaniu...
  };

  return (
    <div className="space-program">
      <h1>Program Kosmiczny</h1>
      <MissionControl
        onLaunch={handleLaunch}
        onAbort={handleAbort}
      />
    </div>
  );
}

Funkcja przekazana do setState (aktualizacja funkcyjna) musi być czysta: React w trybie deweloperskim (StrictMode) wywołuje ją dwa razy, więc wywołanie w niej onLaunch() uruchomiłoby rakietę dwukrotnie. Dlatego sekundy odliczamy w zwykłej zmiennej secondsLeft, a onLaunch() i onAbort() wywołujemy bezpośrednio w kodzie timera i handlera. Identyfikator timera trzymamy w useRef, żeby abortLaunch mógł go zatrzymać - useRef poznasz dokładniej przy komponentach niekontrolowanych w lekcji o przepływie danych.

Obsługa formularzy

Formularze są kluczowym elementem interakcji z użytkownikiem w aplikacjach webowych. React oferuje dwa podejścia do obsługi formularzy: kontrolowane i niekontrolowane komponenty.

Formularze kontrolowane

W kontrolowanych komponentach, dane formularza są kontrolowane przez stan React:

function MissionSetup() {
  const [missionData, setMissionData] = useState({
    name: '',
    destination: 'Moon',
    crew: 3,
    duration: 7
  });

  const handleChange = (e) => {
    const { name, value } = e.target;
    setMissionData({
      ...missionData,
      [name]: value
    });
  };

  const handleSubmit = (e) => {
    e.preventDefault();
    console.log('Dane misji:', missionData);
    // Logika wysyłania danych...
  };

  return (
    <div className="mission-setup">
      <h2>Konfiguracja misji</h2>

      <form onSubmit={handleSubmit}>
        <div className="form-group">
          <label htmlFor="name">Nazwa misji:</label>
          <input
            type="text"
            id="name"
            name="name"
            value={missionData.name}
            onChange={handleChange}
            required
          />
        </div>

        <div className="form-group">
          <label htmlFor="destination">Cel podróży:</label>
          <select
            id="destination"
            name="destination"
            value={missionData.destination}
            onChange={handleChange}
          >
            <option value="Moon">Księżyc</option>
            <option value="Mars">Mars</option>
            <option value="ISS">Międzynarodowa Stacja Kosmiczna</option>
            <option value="Asteroid">Pas asteroid</option>
          </select>
        </div>

        <div className="form-group">
          <label htmlFor="crew">Liczba załogantów:</label>
          <input
            type="number"
            id="crew"
            name="crew"
            min="1"
            max="10"
            value={missionData.crew}
            onChange={handleChange}
          />
        </div>

        <div className="form-group">
          <label htmlFor="duration">Czas trwania (dni):</label>
          <input
            type="number"
            id="duration"
            name="duration"
            min="1"
            value={missionData.duration}
            onChange={handleChange}
          />
        </div>

        <button type="submit">Zaplanuj misję</button>
      </form>
    </div>
  );
}

W powyższym przykładzie:

  1. Każde pole formularza ma swój odpowiednik w stanie
  2. Wartość każdego pola jest kontrolowana przez stan
  3. Zdarzenie onChange aktualizuje stan, co z kolei aktualizuje wartość pola
  4. Zdarzenie onSubmit jest używane do obsługi przesyłania formularza

Obsługa wielu typów pól formularza

Różne pola formularza wymagają nieco innego podejścia:

function AstronautRegistration() {
  const [formData, setFormData] = useState({
    name: '',
    age: '',
    specialty: 'pilot',
    experience: '',
    isTrainee: false,
    bio: '',
    preferredShift: 'morning'
  });

  const handleChange = (e) => {
    const value = e.target.type === 'checkbox' ? e.target.checked : e.target.value;
    setFormData({
      ...formData,
      [e.target.name]: value
    });
  };

  const handleSubmit = (e) => {
    e.preventDefault();
    console.log('Dane astronauty:', formData);
    // Logika rejestracji...
  };

  return (
    <div className="astronaut-registration">
      <h2>Rejestracja astronauty</h2>

      <form onSubmit={handleSubmit}>
        {/* Pole tekstowe */}
        <div className="form-group">
          <label htmlFor="name">Imię i nazwisko:</label>
          <input
            type="text"
            id="name"
            name="name"
            value={formData.name}
            onChange={handleChange}
            required
          />
        </div>

        {/* Pole liczbowe */}
        <div className="form-group">
          <label htmlFor="age">Wiek:</label>
          <input
            type="number"
            id="age"
            name="age"
            value={formData.age}
            onChange={handleChange}
            required
          />
        </div>

        {/* Select */}
        <div className="form-group">
          <label htmlFor="specialty">Specjalizacja:</label>
          <select
            id="specialty"
            name="specialty"
            value={formData.specialty}
            onChange={handleChange}
          >
            <option value="pilot">Pilot</option>
            <option value="engineer">Inżynier</option>
            <option value="scientist">Naukowiec</option>
            <option value="doctor">Lekarz</option>
          </select>
        </div>

        {/* Radio buttons */}
        <div className="form-group">
          <p>Preferowana zmiana:</p>
          <label>
            <input
              type="radio"
              name="preferredShift"
              value="morning"
              checked={formData.preferredShift === 'morning'}
              onChange={handleChange}
            />
            Poranna
          </label>
          <label>
            <input
              type="radio"
              name="preferredShift"
              value="evening"
              checked={formData.preferredShift === 'evening'}
              onChange={handleChange}
            />
            Wieczorna
          </label>
        </div>

        {/* Checkbox */}
        <div className="form-group">
          <label>
            <input
              type="checkbox"
              name="isTrainee"
              checked={formData.isTrainee}
              onChange={handleChange}
            />
            Status praktykanta
          </label>
        </div>

        {/* Textarea */}
        <div className="form-group">
          <label htmlFor="bio">Biografia:</label>
          <textarea
            id="bio"
            name="bio"
            value={formData.bio}
            onChange={handleChange}
            rows="4"
          ></textarea>
        </div>

        {/* Range */}
        <div className="form-group">
          <label htmlFor="experience">Lata doświadczenia: {formData.experience}</label>
          <input
            type="range"
            id="experience"
            name="experience"
            min="0"
            max="30"
            value={formData.experience}
            onChange={handleChange}
          />
        </div>

        <button type="submit">Zarejestruj</button>
      </form>
    </div>
  );
}

Obsługa błędów i walidacja formularzy

W rzeczywistych aplikacjach, ważne jest, aby walidować dane wprowadzane przez użytkownika:

function MissionPlanner() {
  const [formData, setFormData] = useState({
    missionName: '',
    launchDate: '',
    budget: ''
  });

  const [errors, setErrors] = useState({});

  const validateForm = () => {
    const newErrors = {};

    // Walidacja nazwy misji
    if (!formData.missionName.trim()) {
      newErrors.missionName = 'Nazwa misji jest wymagana';
    } else if (formData.missionName.length < 3) {
      newErrors.missionName = 'Nazwa misji musi mieć co najmniej 3 znaki';
    }

    // Walidacja daty startu
    if (!formData.launchDate) {
      newErrors.launchDate = 'Data startu jest wymagana';
    } else {
      const selectedDate = new Date(formData.launchDate);
      const today = new Date();

      if (selectedDate <= today) {
        newErrors.launchDate = 'Data startu musi być w przyszłości';
      }
    }

    // Walidacja budżetu
    if (!formData.budget) {
      newErrors.budget = 'Budżet jest wymagany';
    } else if (isNaN(formData.budget) || Number(formData.budget) <= 0) {
      newErrors.budget = 'Budżet musi być liczbą dodatnią';
    }

    setErrors(newErrors);
    return Object.keys(newErrors).length === 0; // Formularz jest prawidłowy, jeśli nie ma błędów
  };

  const handleChange = (e) => {
    const { name, value } = e.target;
    setFormData({
      ...formData,
      [name]: value
    });

    // Usuwanie błędu dla pola, które jest zmieniane
    if (errors[name]) {
      setErrors({
        ...errors,
        [name]: undefined
      });
    }
  };

  const handleSubmit = (e) => {
    e.preventDefault();

    if (validateForm()) {
      console.log('Dane misji zostały wysłane:', formData);
      // Logika wysyłania danych...
    } else {
      console.log('Formularz zawiera błędy');
    }
  };

  return (
    <div className="mission-planner">
      <h2>Planowanie misji kosmicznej</h2>

      <form onSubmit={handleSubmit}>
        <div className="form-group">
          <label htmlFor="missionName">Nazwa misji:</label>
          <input
            type="text"
            id="missionName"
            name="missionName"
            value={formData.missionName}
            onChange={handleChange}
            className={errors.missionName ? 'error' : ''}
          />
          {errors.missionName && <div className="error-message">{errors.missionName}</div>}
        </div>

        <div className="form-group">
          <label htmlFor="launchDate">Data startu:</label>
          <input
            type="date"
            id="launchDate"
            name="launchDate"
            value={formData.launchDate}
            onChange={handleChange}
            className={errors.launchDate ? 'error' : ''}
          />
          {errors.launchDate && <div className="error-message">{errors.launchDate}</div>}
        </div>

        <div className="form-group">
          <label htmlFor="budget">Budżet (w milionach $):</label>
          <input
            type="number"
            id="budget"
            name="budget"
            value={formData.budget}
            onChange={handleChange}
            className={errors.budget ? 'error' : ''}
          />
          {errors.budget && <div className="error-message">{errors.budget}</div>}
        </div>

        <button type="submit">Zaplanuj misję</button>
      </form>
    </div>
  );
}

Podsumowanie

Obsługa zdarzeń jest kluczowym elementem tworzenia interaktywnych aplikacji w React. Dzięki niej możemy:

  1. Reagować na działania użytkownika, takie jak kliknięcia, ruch myszy, czy wprowadzanie tekstu
  2. Aktualizować stan komponentu na podstawie interakcji
  3. Komunikować się między komponentami poprzez przekazywanie funkcji jako props
  4. Obsługiwać formularze i walidować dane wprowadzane przez użytkownika

Prawidłowa obsługa zdarzeń, w połączeniu z zarządzaniem stanem, pozwala tworzyć dynamiczne, responsywne interfejsy użytkownika, które zapewniają użytkownikom intuicyjne doświadczenie.

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

function EventDemo() {
  const [clickCount, setClickCount] = useState(0);
  const [inputText, setInputText] = useState('');
  const [isHovered, setIsHovered] = useState(false);
  const [selectedOption, setSelectedOption] = useState('Mars');

  const handleButtonClick = () => {
    setClickCount(clickCount + 1);
  };

  const handleInputChange = (event) => {
    setInputText(event.target.value);
  };

  const handleSubmit = (event) => {
    event.preventDefault();
    alert(`Formularz wysłany z tekstem: "${inputText}"`);
  };

  const handleKeyDown = (event) => {
    if (event.key === 'Enter') {
      alert('Naciśnięto Enter!');
    }
  };

  return (
    <div className="event-demo">
      <h1>Demo obsługi zdarzeń w React</h1>

      <div className="demo-section">
        <h2>Zdarzenia myszy</h2>
        <button
          onClick={handleButtonClick}
          onMouseEnter={() => setIsHovered(true)}
          onMouseLeave={() => setIsHovered(false)}
          className={isHovered ? 'hovered' : ''}
        >
          Kliknij mnie! (Kliknięto: {clickCount} razy)
        </button>
      </div>

      <div className="demo-section">
        <h2>Zdarzenia formularza</h2>
        <form onSubmit={handleSubmit}>
          <input
            type="text"
            value={inputText}
            onChange={handleInputChange}
            onKeyDown={handleKeyDown}
            placeholder="Wpisz tekst i naciśnij Enter lub wyślij formularz"
          />
          <select
            value={selectedOption}
            onChange={(e) => setSelectedOption(e.target.value)}
          >
            <option value="Mars">Mars</option>
            <option value="Księżyc">Księżyc</option>
            <option value="Wenus">Wenus</option>
            <option value="Jowisz">Jowisz</option>
          </select>
          <button type="submit">Wyślij formularz</button>
        </form>

        <div className="output">
          <p>Aktualny tekst: {inputText}</p>
          <p>Wybrana opcja: {selectedOption}</p>
        </div>
      </div>

      <div className="demo-section">
        <h2>Zdarzenia dotyku i interakcji</h2>
        <div
          className="interactive-area"
          onTouchStart={() => console.log('Dotyk rozpoczęty')}
          onTouchEnd={() => console.log('Dotyk zakończony')}
          onDoubleClick={() => alert('Podwójne kliknięcie!')}
        >
          Kliknij podwójnie lub dotknij (sprawdź konsolę)
        </div>
      </div>
    </div>
  );
}

function App() {
  return (
    <div className="app">
      <EventDemo />
    </div>
  );
}

export default App;

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż poprawną składnię aktualizacji stanu z użyciem poprzedniej wartości:

  • Edytor kodu

    Stwórz licznik tlenu: const [oxygen, setOxygen] = useState(21). Wyświetl tekst Poziom O2: {oxygen}% i dodaj dwa przyciski: przycisk + zwiększa poziom o 1 (<button onClick={() => setOxygen(prev => prev + 1)}>+</button>), a przycisk - zmniejsza go o 1. Poziom nie może wyjść poza zakres 0-100.

  • Klikanie w kolejności

    Zbuduj poprawny atrybut obsługi kliknięcia w JSX:

  • Klikanie w kolejności

    Ułóż proces używania useState:

  1. Ułóż w kolejnościSkładnia funkcyjnej aktualizacji stanu
  2. Zadanie z kodemPraktyka: Licznik z useState
  3. Kliknij w kolejnościSkładnia onClick w JSX
  4. Kliknij w kolejnościSortowanie: Przepływ pracy z useState

Przydatne artykuły