Kurs JavaScript i React · Moduł 3: Stan i zdarzenia
Formularze w React - kontrolowane komponenty
W tej lekcji6
Na pokładzie statku kosmicznego React formularze to jak panele konfiguracyjne - służą do wprowadzania danych nawigacyjnych, ustawiania parametrów misji i komunikacji z centrum dowodzenia. W tej lekcji poznasz kontrolowane komponenty - wzorzec, w którym React przejmuje pełną kontrolę nad danymi formularza, tak jak komputer pokładowy kontroluje każdy system statku.
Kontrolowane vs niekontrolowane komponenty
W React wyróżniamy dwa podejścia do obsługi formularzy:
Kontrolowane komponenty - React zarządza wartością inputa poprzez state. Każda zmiana przechodzi przez useState i onChange:
function ControlledInput() {
const [name, setName] = useState("");
return (
<input
type="text"
value={name}
onChange={(e) => setName(e.target.value)}
/>
);
}Niekontrolowane komponenty - przeglądarka zarządza wartością, a my odczytujemy ją przez ref:
function UncontrolledInput() {
const inputRef = useRef(null);
const handleSubmit = (e) => {
e.preventDefault();
console.log(inputRef.current.value);
};
return (
<form onSubmit={handleSubmit}>
<input type="text" ref={inputRef} />
<button type="submit">Wyślij</button>
</form>
);
}Dlaczego kontrolowane komponenty są lepsze? Tak jak komputer pokładowy statku musi znać stan każdego systemu w każdej chwili, kontrolowane komponenty dają Reactowi pełny wgląd w dane formularza. Dzięki temu możesz walidować, formatować i reagować na zmiany w czasie rzeczywistym.
Obsługa pól tekstowych z useState
Prosty input tekstowy
function PilotRegistration() {
const [pilotName, setPilotName] = useState("");
const [callSign, setCallSign] = useState("");
return (
<div className="registration-form">
<h2>Rejestracja pilota</h2>
<label>Imię pilota:</label>
<input
type="text"
value={pilotName}
onChange={(e) => setPilotName(e.target.value)}
placeholder="Wpisz imię..."
/>
<label>Znak wywoławczy:</label>
<input
type="text"
value={callSign}
onChange={(e) => setCallSign(e.target.value.toUpperCase())}
placeholder="Np. ALPHA-7"
/>
<p>Pilot: {pilotName} ({callSign})</p>
</div>
);
}Zarządzanie wieloma polami jednym stanem
Zamiast tworzyć osobny useState dla każdego pola, możesz użyć jednego obiektu stanu - jak centralny rejestr danych misji:
function MissionConfigForm() {
const [formData, setFormData] = useState({
missionName: "",
destination: "",
crewSize: "",
priority: "normal"
});
const handleChange = (event) => {
const { name, value } = event.target;
setFormData((prev) => ({
...prev,
[name]: value
}));
};
return (
<div className="mission-config">
<h2>Konfiguracja misji</h2>
<label>Nazwa misji:</label>
<input
type="text"
name="missionName"
value={formData.missionName}
onChange={handleChange}
/>
<label>Cel podróży:</label>
<input
type="text"
name="destination"
value={formData.destination}
onChange={handleChange}
/>
<label>Rozmiar załogi:</label>
<input
type="number"
name="crewSize"
value={formData.crewSize}
onChange={handleChange}
/>
<label>Priorytet:</label>
<input
type="text"
name="priority"
value={formData.priority}
onChange={handleChange}
/>
<pre>{JSON.stringify(formData, null, 2)}</pre>
</div>
);
}Kluczowa sztuczka: atrybut name na inputach odpowiada kluczom w obiekcie stanu, a [name]: value (computed property name) dynamicznie aktualizuje odpowiednie pole.
Checkboxy i elementy select
Checkbox - przełączniki systemów
Checkboxy w React używają checked zamiast value:
function ShipSystemsPanel() {
const [systems, setSystems] = useState({
engines: true,
shields: false,
weapons: false,
lifeSupport: true
});
const handleToggle = (event) => {
const { name, checked } = event.target;
setSystems((prev) => ({
...prev,
[name]: checked
}));
};
return (
<div className="systems-panel">
<h2>Systemy statku</h2>
<label>
<input
type="checkbox"
name="engines"
checked={systems.engines}
onChange={handleToggle}
/>
Silniki
</label>
<label>
<input
type="checkbox"
name="shields"
checked={systems.shields}
onChange={handleToggle}
/>
Tarcze ochronne
</label>
<label>
<input
type="checkbox"
name="weapons"
checked={systems.weapons}
onChange={handleToggle}
/>
Systemy uzbrojenia
</label>
<label>
<input
type="checkbox"
name="lifeSupport"
checked={systems.lifeSupport}
onChange={handleToggle}
/>
Podtrzymywanie życia
</label>
<div className="status">
Aktywne systemy: {Object.entries(systems)
.filter(([, active]) => active)
.map(([name]) => name)
.join(", ")}
</div>
</div>
);
}Select - wybór z listy
Element <select> w React działa jak inne kontrolowane inputy - wartość kontrolujemy przez value i onChange:
function NavigationPanel() {
const [destination, setDestination] = useState("");
const [warpSpeed, setWarpSpeed] = useState("1");
const destinations = [
{ value: "mars", label: "Mars" },
{ value: "jupiter", label: "Jowisz" },
{ value: "saturn", label: "Saturn" },
{ value: "alpha-centauri", label: "Alfa Centauri" },
{ value: "andromeda", label: "Galaktyka Andromedy" }
];
return (
<div className="nav-panel">
<h2>Panel nawigacji</h2>
<label>Cel podróży:</label>
<select
value={destination}
onChange={(e) => setDestination(e.target.value)}
>
<option value="">-- Wybierz cel --</option>
{destinations.map((dest) => (
<option key={dest.value} value={dest.value}>
{dest.label}
</option>
))}
</select>
<label>Prędkość warp:</label>
<select
value={warpSpeed}
onChange={(e) => setWarpSpeed(e.target.value)}
>
<option value="1">Warp 1</option>
<option value="3">Warp 3</option>
<option value="5">Warp 5</option>
<option value="9">Warp 9 (maksimum)</option>
</select>
{destination && (
<p>Kurs ustawiony: {destination} z prędkością Warp {warpSpeed}</p>
)}
</div>
);
}Obsługa wysyłania formularza
Wysyłanie formularza to jak nadanie rozkazu z centrum dowodzenia - musi być kontrolowane i bezpieczne:
function MissionReportForm() {
const [formData, setFormData] = useState({
missionName: "",
commander: "",
status: "in-progress",
description: "",
isClassified: false
});
const [submitted, setSubmitted] = useState(false);
const handleChange = (event) => {
const { name, value, type, checked } = event.target;
setFormData((prev) => ({
...prev,
[name]: type === "checkbox" ? checked : value
}));
};
const handleSubmit = (event) => {
event.preventDefault();
// Walidacja
if (!formData.missionName.trim() || !formData.commander.trim()) {
alert("Wypełnij wszystkie wymagane pola!");
return;
}
console.log("Raport misji:", formData);
setSubmitted(true);
};
const handleReset = () => {
setFormData({
missionName: "",
commander: "",
status: "in-progress",
description: "",
isClassified: false
});
setSubmitted(false);
};
if (submitted) {
return (
<div className="success">
<h2>Raport wysłany!</h2>
<p>Misja: {formData.missionName}</p>
<button onClick={handleReset}>Nowy raport</button>
</div>
);
}
return (
<form onSubmit={handleSubmit} className="mission-report">
<h2>Raport misji</h2>
<label>Nazwa misji *:</label>
<input
type="text"
name="missionName"
value={formData.missionName}
onChange={handleChange}
required
/>
<label>Dowódca *:</label>
<input
type="text"
name="commander"
value={formData.commander}
onChange={handleChange}
required
/>
<label>Status:</label>
<select name="status" value={formData.status} onChange={handleChange}>
<option value="in-progress">W trakcie</option>
<option value="completed">Zakończona</option>
<option value="failed">Niepowodzenie</option>
</select>
<label>Opis:</label>
<textarea
name="description"
value={formData.description}
onChange={handleChange}
rows={4}
placeholder="Opisz przebieg misji..."
/>
<label>
<input
type="checkbox"
name="isClassified"
checked={formData.isClassified}
onChange={handleChange}
/>
Raport tajny
</label>
<div className="form-actions">
<button type="submit">Wyślij raport</button>
<button type="button" onClick={handleReset}>Wyczyść</button>
</div>
</form>
);
}Lifting state up - podnoszenie stanu
Kiedy kilka komponentów musi współdzielić dane formularza, przenosimy stan do ich wspólnego rodzica - jak centrala dowodzenia koordynująca dane z wielu paneli:
function TemperatureInput({ label, value, onChange }) {
return (
<div>
<label>{label}:</label>
<input
type="number"
value={value}
onChange={(e) => onChange(e.target.value)}
/>
</div>
);
}
function TemperatureConverter() {
// Rodzic pamięta tylko to, co wpisano ostatnio, i w której skali
const [temperature, setTemperature] = useState({ scale: "c", value: "" });
const convert = (value, formula) => {
const number = parseFloat(value);
return Number.isNaN(number) ? "" : String(Math.round(formula(number) * 100) / 100);
};
const celsius = temperature.scale === "f"
? convert(temperature.value, (f) => ((f - 32) * 5) / 9)
: temperature.value;
const fahrenheit = temperature.scale === "c"
? convert(temperature.value, (c) => (c * 9) / 5 + 32)
: temperature.value;
return (
<div className="converter">
<h2>Konwerter temperatury kadłuba</h2>
<TemperatureInput
label="Celsius"
value={celsius}
onChange={(value) => setTemperature({ scale: "c", value })}
/>
<TemperatureInput
label="Fahrenheit"
value={fahrenheit}
onChange={(value) => setTemperature({ scale: "f", value })}
/>
</div>
);
}W tym wzorcu:
- Stan (
temperature: ostatnio wpisana wartość i jej skala) żyje w rodzicu (TemperatureConverter) - Komponenty dzieci (
TemperatureInput) otrzymują wartość przez props - Zmiany przekazywane są w górę przez callback
onChange - Rodzic przelicza i synchronizuje obie wartości
Rodzic nie zapisuje gotowych stopni Celsjusza, tylko ostatnio wpisaną wartość i jej skalę. Dzięki temu pole, w którym piszesz, pokazuje dokładnie to, co wpisujesz (także samo - albo 10), a drugie pole jest przeliczane i zaokrąglane do dwóch miejsc po przecinku.
Podsumowanie
Formularze w React - kluczowe zasady:
- Kontrolowane komponenty - React zarządza wartością inputów przez
value+onChange - Jeden state dla wielu pól - użyj obiektu stanu z dynamicznym
[name]: value - Checkboxy - używaj
checkedzamiastvalue, odczytujevent.target.checked - Select - kontroluj przez
valuena<select>, nie na<option> - preventDefault() - zawsze blokuj domyślne wysyłanie formularza
- Walidacja - sprawdzaj dane w handlerze
onSubmitprzed wysłaniem - Lifting state up - przenieś stan do wspólnego rodzica, gdy komponenty muszą współdzielić dane
Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
function SpaceMissionForm() {
const [formData, setFormData] = useState({
missionName: '',
destination: 'mars',
crewSize: 4,
duration: '',
priority: 'medium',
equipment: [],
notes: '',
launchDate: '',
isUrgent: false
});
const [errors, setErrors] = useState({});
const [submitted, setSubmitted] = useState(false);
const equipmentOptions = [
{ id: 'rover', label: 'Łazik' },
{ id: 'drone', label: 'Dron' },
{ id: 'satellite', label: 'Satelita' },
{ id: 'telescope', label: 'Teleskop' },
{ id: 'lab', label: 'Laboratorium' }
];
const handleChange = (e) => {
const { name, value, type, checked } = e.target;
setFormData(prev => ({
...prev,
[name]: type === 'checkbox' ? checked : value
}));
if (errors[name]) {
setErrors(prev => ({ ...prev, [name]: null }));
}
};
const handleEquipmentChange = (id) => {
setFormData(prev => ({
...prev,
equipment: prev.equipment.includes(id)
? prev.equipment.filter(e => e !== id)
: [...prev.equipment, id]
}));
};
const validate = () => {
const newErrors = {};
if (!formData.missionName.trim()) newErrors.missionName = 'Nazwa misji jest wymagana';
if (!formData.duration || formData.duration < 1) newErrors.duration = 'Czas trwania musi być większy niż 0';
if (!formData.launchDate) newErrors.launchDate = 'Data startu jest wymagana';
if (formData.equipment.length === 0) newErrors.equipment = 'Wybierz przynajmniej jedno wyposażenie';
return newErrors;
};
const handleSubmit = (e) => {
e.preventDefault();
const newErrors = validate();
if (Object.keys(newErrors).length > 0) {
setErrors(newErrors);
return;
}
setSubmitted(true);
console.log('Submitted:', formData);
};
const handleReset = () => {
setFormData({
missionName: '', destination: 'mars', crewSize: 4, duration: '',
priority: 'medium', equipment: [], notes: '', launchDate: '', isUrgent: false
});
setErrors({});
setSubmitted(false);
};
if (submitted) {
return (
<div style={{ fontFamily: 'Arial', padding: '40px', textAlign: 'center' }}>
<div style={{ fontSize: '64px', marginBottom: '20px' }}>▲</div>
<h1 style={{ color: '#4caf50' }}>Misja zaplanowana!</h1>
<div style={{ backgroundColor: '#f5f5f5', padding: '20px', borderRadius: '12px', maxWidth: '500px', margin: '20px auto', textAlign: 'left' }}>
<p><strong>Nazwa:</strong> {formData.missionName}</p>
<p><strong>Cel:</strong> {formData.destination}</p>
<p><strong>Załoga:</strong> {formData.crewSize} osób</p>
<p><strong>Czas trwania:</strong> {formData.duration} dni</p>
<p><strong>Data startu:</strong> {formData.launchDate}</p>
<p><strong>Wyposażenie:</strong> {formData.equipment.join(', ')}</p>
</div>
<button onClick={handleReset} style={{ padding: '12px 24px', backgroundColor: '#667eea', color: 'white', border: 'none', borderRadius: '8px', cursor: 'pointer' }}>
Zaplanuj nową misję
</button>
</div>
);
}
return (
<div style={{ fontFamily: 'Arial', padding: '20px', maxWidth: '600px', margin: '0 auto' }}>
<h1 style={{ textAlign: 'center', color: '#667eea' }}>Planowanie Misji Kosmicznej</h1>
<form onSubmit={handleSubmit} style={{ display: 'flex', flexDirection: 'column', gap: '20px' }}>
<div>
<label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Nazwa misji *</label>
<input type="text" name="missionName" value={formData.missionName} onChange={handleChange}
style={{ width: '100%', padding: '10px', borderRadius: '8px', border: errors.missionName ? '2px solid #f44336' : '1px solid #ddd', boxSizing: 'border-box' }}
/>
{errors.missionName && <span style={{ color: '#f44336', fontSize: '12px' }}>{errors.missionName}</span>}
</div>
<div>
<label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Cel podróży</label>
<select name="destination" value={formData.destination} onChange={handleChange}
style={{ width: '100%', padding: '10px', borderRadius: '8px', border: '1px solid #ddd' }}>
<option value="mars">Mars</option>
<option value="moon">Księżyc</option>
<option value="venus">Wenus</option>
<option value="jupiter">Jowisz</option>
<option value="saturn">Saturn</option>
</select>
</div>
<div>
<label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Wielkość załogi: {formData.crewSize}</label>
<input type="range" name="crewSize" min="1" max="20" value={formData.crewSize} onChange={handleChange}
style={{ width: '100%' }}
/>
</div>
<div>
<label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Czas trwania (dni) *</label>
<input type="number" name="duration" value={formData.duration} onChange={handleChange}
style={{ width: '100%', padding: '10px', borderRadius: '8px', border: errors.duration ? '2px solid #f44336' : '1px solid #ddd', boxSizing: 'border-box' }}
/>
{errors.duration && <span style={{ color: '#f44336', fontSize: '12px' }}>{errors.duration}</span>}
</div>
<div>
<label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Data startu *</label>
<input type="date" name="launchDate" value={formData.launchDate} onChange={handleChange}
style={{ width: '100%', padding: '10px', borderRadius: '8px', border: errors.launchDate ? '2px solid #f44336' : '1px solid #ddd', boxSizing: 'border-box' }}
/>
{errors.launchDate && <span style={{ color: '#f44336', fontSize: '12px' }}>{errors.launchDate}</span>}
</div>
<div>
<label style={{ display: 'block', marginBottom: '10px', fontWeight: 'bold' }}>Priorytet</label>
<div style={{ display: 'flex', gap: '20px' }}>
{['low', 'medium', 'high'].map(p => (
<label key={p} style={{ display: 'flex', alignItems: 'center', gap: '5px' }}>
<input type="radio" name="priority" value={p} checked={formData.priority === p} onChange={handleChange} />
{p === 'low' ? 'Niski' : p === 'medium' ? 'Średni' : 'Wysoki'}
</label>
))}
</div>
</div>
<div>
<label style={{ display: 'block', marginBottom: '10px', fontWeight: 'bold' }}>Wyposażenie *</label>
<div style={{ display: 'flex', flexWrap: 'wrap', gap: '10px' }}>
{equipmentOptions.map(eq => (
<label key={eq.id} style={{
padding: '8px 16px', borderRadius: '20px', cursor: 'pointer',
backgroundColor: formData.equipment.includes(eq.id) ? '#667eea' : '#e0e0e0',
color: formData.equipment.includes(eq.id) ? 'white' : '#333'
}}>
<input type="checkbox" checked={formData.equipment.includes(eq.id)}
onChange={() => handleEquipmentChange(eq.id)} style={{ display: 'none' }}
/>
{eq.label}
</label>
))}
</div>
{errors.equipment && <span style={{ color: '#f44336', fontSize: '12px' }}>{errors.equipment}</span>}
</div>
<div>
<label style={{ display: 'flex', alignItems: 'center', gap: '10px', cursor: 'pointer' }}>
<input type="checkbox" name="isUrgent" checked={formData.isUrgent} onChange={handleChange} />
<span style={{ fontWeight: 'bold' }}>Misja pilna</span>
</label>
</div>
<div>
<label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Notatki</label>
<textarea name="notes" value={formData.notes} onChange={handleChange} rows="3"
style={{ width: '100%', padding: '10px', borderRadius: '8px', border: '1px solid #ddd', boxSizing: 'border-box', resize: 'vertical' }}
/>
</div>
<div style={{ display: 'flex', gap: '10px' }}>
<button type="submit" style={{ flex: 1, padding: '12px', backgroundColor: '#4caf50', color: 'white', border: 'none', borderRadius: '8px', cursor: 'pointer', fontWeight: 'bold' }}>
Zaplanuj misję
</button>
<button type="button" onClick={handleReset} style={{ flex: 1, padding: '12px', backgroundColor: '#f44336', color: 'white', border: 'none', borderRadius: '8px', cursor: 'pointer', fontWeight: 'bold' }}>
Wyczyść
</button>
</div>
</form>
</div>
);
}
export default function App() {
return <SpaceMissionForm />;
}Pamiętaj: Kontrolowane komponenty to jak system sterowania statkiem - komputer pokładowy (React) wie o każdej zmianie w czasie rzeczywistym i może natychmiast zareagować!
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. Czy można używać wielu useState w jednym komponencie?
2. Jaka jest różnica między state a props?
To 2 z 9 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Klikanie w kolejności
Zbuduj handler onSubmit zapobiegający przeładowaniu strony:
- Układanie w pionie
Ułóż etapy tworzenia kontrolowanego formularza w React:
- Edytor kodu
Stwórz komponent EmergencyAlert ze stanem message wyświetlanym w akapicie <p> i wyrenderuj go w App. Dodaj przycisk ALARM: onClick ustawia komunikat 'Alarm aktywowany!', a onMouseEnter komunikat 'Uwaga: kursor nad przyciskiem alarmu'. Dodaj też pole <input> z onKeyDown, które po wciśnięciu Enter (e.key === 'Enter') ustawia komunikat 'Alarm uruchomiony z klawiatury', a inne klawisze ignoruje.
- Edytor kodu
Stwórz rodzica ColonyControl ze stanem powerLevel (useState(50)) i dwoje dzieci bez własnego stanu: PowerPlant({ powerLevel, onPowerChange }) wyświetla poziom mocy i ma przyciski +10 i -10, które wywołują onPowerChange z nową wartością, oraz LifeSupport({ powerLevel }), który wyświetla 'Systemy podtrzymywania życia: aktywne', gdy powerLevel >= 30, a w przeciwnym razie 'ALARM: za mało mocy'. ColonyControl przekazuje obu dzieciom ten sam powerLevel. Wyrenderuj ColonyControl w App.
- Edytor kodu
Stwórz komponent ColonyDashboard z czterema osobnymi stanami useState: temperature (np. -20), pressure (np. 600), oxygen (np. 21) i power (np. 80), i wyrenderuj go w App. Wyświetl wszystkie cztery wartości, a dla każdej dodaj przycisk, który zmienia tylko ją (np. Ogrzej +5, Ciśnienie +10, Tlen +1, Zasilanie -10).
- Klikanie w kolejności
Zbuduj wyrażenie pobierające wartość z pola input w event handlerze:
- Układanie w poziomie
Ułóż składnię importu hooka useState z React:
- Klikanie w kolejności
Ułóż etapy obsługi zdarzenia:
- Układanie w pionie
Ułóż sposoby przechowywania stanu od najprostszego do najbardziej rozbudowanego, tak jak w lekcji o przepływie danych:
- Układanie w pionie
Ułóż, co się dzieje po wpisaniu jednego znaku w kontrolowane pole <input value={name} onChange={(e) => setName(e.target.value)} />:
- Klikanie w kolejności
Ułóż kroki aktualizacji stanu:
- Układanie w poziomie
Ułóż poprawny atrybut onChange dla kontrolowanego inputa:
- Klikanie w kolejności
Kliknij elementy w kolejności tworzenia kontrolowanego inputa z onChange:
- Układanie w pionie
Ułóż kroki cyklu aktualizacji stanu w React od zdarzenia do aktualizacji DOM:
- Układanie w poziomie
Ułóż poprawną aktualizację jednej właściwości obiektu w useState:
- Układanie w pionie
Ułóż kroki walidacji w formularzu MissionPlanner z lekcji o obsłudze zdarzeń:
Zadania po tej lekcji
- Kliknij w kolejnościHandler onSubmit z preventDefault
- PytanieWiele zmiennych stanu
- Ułóż w kolejnościEtapy budowy kontrolowanego formularza
- Zadanie z kodemPraktyka: Zdarzenia onClick, onMouseEnter i onKeyDown
- PytanieState vs Props
- Zadanie z kodemPraktyka: Lifting state up
- PytaniePodnoszenie stanu
- Zadanie z kodemPraktyka: Wiele stanów
- PytanieEvent handler onClick
- Kliknij w kolejnościDostęp do wartości input przez event
- PytanieKontrolowane vs niekontrolowane komponenty
- Ułóż w kolejnościImport hooka useState
- Kliknij w kolejnościSortowanie: Przepływ obsługi zdarzeń
- Ułóż w kolejnościWzorce zarządzania stanem
- Ułóż w kolejnościCykl kontrolowanego pola formularza
- Kliknij w kolejnościSortowanie: proces aktualizacji stanu
- PytanieAsynchroniczna aktualizacja stanu
- Ułóż w kolejnościSkładnia onChange dla kontrolowanego inputa
- PytanieZalety kontrolowanych komponentów
- PytanieInicjalizacja useState
- PytanieWzorzec lifting state up
- Kliknij w kolejnościSkładnia kontrolowanego inputa
- Ułóż w kolejnościCykl aktualizacji stanu w React
- Ułóż w kolejnościAktualizacja obiektu operatorem spread
- Ułóż w kolejnościWalidacja formularza krok po kroku