Kurs JavaScript i React · Moduł 3: Stan i zdarzenia
Obsługa zdarzeń
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:
Nazwy zdarzeń używają konwencji camelCase zamiast małych liter:
- HTML:
onclick,onmouseover - React:
onClick,onMouseOver
- HTML:
W JSX przekazujemy funkcję jako handler zdarzenia, a nie string:
- HTML:
<button onclick="handleClick()">Kliknij</button> - React:
<button onClick={handleClick}>Kliknij</button>
- HTML:
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>
- HTML:
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ęcieonDoubleClick- podwójne kliknięcieonMouseEnter- najechanie kursorem na elementonMouseLeave- wyjście kursorem poza elementonMouseMove- ruch kursora nad elementem
Zdarzenia formularzy
onChange- zmiana wartości elementu formularzaonSubmit- wysłanie formularzaonFocus- element otrzymuje focusonBlur- element traci focus
Zdarzenia klawiatury
onKeyDown- wciśnięcie klawiszaonKeyPress- przestarzałe, zamiast niego używajonKeyDownonKeyUp- zwolnienie klawisza
Zdarzenia dotyku (dla urządzeń mobilnych)
onTouchStart- rozpoczęcie dotykuonTouchMove- ruch podczas dotykuonTouchEnd- 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:
- Każde pole formularza ma swój odpowiednik w stanie
- Wartość każdego pola jest kontrolowana przez stan
- Zdarzenie
onChangeaktualizuje stan, co z kolei aktualizuje wartość pola - Zdarzenie
onSubmitjest 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:
- Reagować na działania użytkownika, takie jak kliknięcia, ruch myszy, czy wprowadzanie tekstu
- Aktualizować stan komponentu na podstawie interakcji
- Komunikować się między komponentami poprzez przekazywanie funkcji jako props
- 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: