Kurs JavaScript i React · Moduł 3: Stan i zdarzenia
Stan komponentu (State)
W tej lekcji6
W kosmicznej podróży przez galaktykę React, stan (state) jest jak paliwo rakietowe napędzające interaktywność twoich komponentów. Bez stanu, komponenty byłyby statycznymi obiektami - jak planety bez atmosfery. Stan pozwala komponentom "pamiętać" informacje i reagować na zmiany, czyniąc twoje aplikacje żywymi i responsywnymi.
Czym jest stan komponentu?
Stan to dane (liczba, tekst, wartość logiczna, tablica albo obiekt), które komponent pamięta między kolejnymi renderami. W przeciwieństwie do props, które są przekazywane do komponentu przez rodzica, stan należy do samego komponentu i tylko on może go zmienić - zawsze przez funkcję ustawiającą, np. setFuel, a nie przez bezpośrednią modyfikację.
Wyobraź sobie panel kontrolny statku kosmicznego. Props to jak ustalone współrzędne docelowe - nie możesz ich zmienić z poziomu panelu. Stan natomiast to jak aktualne wskazania prędkości, wysokości, temperatury - dane, które nieustannie się zmieniają i są kontrolowane przez sam panel.
Zarządzanie stanem w komponentach funkcyjnych
W nowoczesnym React, stan w komponentach funkcyjnych zarządzany jest za pomocą hooka useState. Ten prosty, ale potężny hook pozwala na dodanie stanu do komponentów funkcyjnych.
Podstawowa składnia useState
import React, { useState } from 'react';
function ControlPanel() {
// Deklaracja zmiennej stanu "fuel" z wartością początkową 100
const [fuel, setFuel] = useState(100);
// fuel - aktualna wartość stanu
// setFuel - funkcja do aktualizacji stanu
return (
<div className="control-panel">
<h2>Panel sterowania</h2>
<p>Poziom paliwa: {fuel}%</p>
<button onClick={() => setFuel(fuel - 10)}>
Zużyj paliwo
</button>
</div>
);
}W powyższym przykładzie:
- Importujemy hook
useStatez Reacta - Wywołujemy
useState(100), aby stworzyć zmienną stanufuelz wartością początkową 100 - Destrukturyzujemy wynik, aby uzyskać:
fuel: aktualną wartość stanusetFuel: funkcję do aktualizacji tej wartości
- Używamy
setFuelw handlerze zdarzenia kliknięcia, aby zmniejszyć wartość paliwa o 10
Używanie wielu zmiennych stanu
Komponent może mieć wiele niezależnych zmiennych stanu:
function SpaceshipDashboard() {
const [fuel, setFuel] = useState(100);
const [speed, setSpeed] = useState(0);
const [shields, setShields] = useState(true);
const [destination, setDestination] = useState('Orbita');
return (
<div className="dashboard">
<h2>Pulpit statku kosmicznego</h2>
<div className="gauges">
<div className="gauge">
<h3>Paliwo</h3>
<p>{fuel}%</p>
<button onClick={() => setFuel(Math.max(0, fuel - 5))}>
Zwiększ ciąg
</button>
</div>
<div className="gauge">
<h3>Prędkość</h3>
<p>{speed} km/s</p>
<button onClick={() => setSpeed(speed + 1)}>
Przyspiesz
</button>
<button onClick={() => setSpeed(Math.max(0, speed - 1))}>
Zwolnij
</button>
</div>
<div className="gauge">
<h3>Tarcze</h3>
<p>{shields ? 'Włączone' : 'Wyłączone'}</p>
<button onClick={() => setShields(!shields)}>
Przełącz
</button>
</div>
<div className="gauge">
<h3>Cel podróży</h3>
<p>{destination}</p>
<select
value={destination}
onChange={(e) => setDestination(e.target.value)}
>
<option value="Orbita">Orbita Ziemi</option>
<option value="Księżyc">Księżyc</option>
<option value="Mars">Mars</option>
<option value="Pas asteroid">Pas asteroid</option>
</select>
</div>
</div>
</div>
);
}Złożone struktury stanu
Stan może być prostą wartością (liczba, string, boolean), ale może też być bardziej złożoną strukturą, jak tablica czy obiekt:
function CrewManagement() {
const [crew, setCrew] = useState([
{ id: 1, name: 'Anna Nowak', role: 'Kapitan', onDuty: true },
{ id: 2, name: 'Jan Kowalski', role: 'Nawigator', onDuty: false },
{ id: 3, name: 'Maria Wiśniewska', role: 'Inżynier', onDuty: true }
]);
const toggleDuty = (crewId) => {
setCrew(crew.map(member =>
member.id === crewId
? { ...member, onDuty: !member.onDuty }
: member
));
};
return (
<div className="crew-management">
<h2>Zarządzanie załogą</h2>
<ul className="crew-list">
{crew.map(member => (
<li key={member.id} className={member.onDuty ? 'on-duty' : 'off-duty'}>
<strong>{member.name}</strong> - {member.role}
<button onClick={() => toggleDuty(member.id)}>
{member.onDuty ? 'Zakończ służbę' : 'Rozpocznij służbę'}
</button>
</li>
))}
</ul>
</div>
);
}W tym przykładzie stan crew to tablica obiektów. Funkcja toggleDuty używa map do tworzenia nowej tablicy z zaktualizowanym stanem konkretnego członka załogi.
State jako migawka
W React, state działa jak migawka (snapshot). Kiedy React renderuje komponent, "zatrzaskuje" stan w czasie, a wszystkie wartości wewnątrz funkcji renderującej (w tym handlery zdarzeń) będą "widzieć" tę samą migawkę stanu.
Rozważmy przykład:
function RocketLauncher() {
const [countdown, setCountdown] = useState(10);
const decrementCountdown = () => {
// To NIE zadziała jak oczekujemy, jeśli chcemy
// wykonać wielokrotne odliczanie w jednym cyklu renderowania
setCountdown(countdown - 1); // Używa tej samej wartości ze snapshota
setCountdown(countdown - 1); // Wciąż używa tej samej wartości!
};
return (
<div className="rocket-launcher">
<h2>Odliczanie do startu: {countdown}</h2>
<button onClick={decrementCountdown}>
Zmniejsz odliczanie
</button>
</div>
);
}W powyższym przykładzie, mimo dwukrotnego wywołania setCountdown, wartość zostanie zmniejszona tylko o 1, a nie o 2. Dzieje się tak, ponieważ obie aktualizacje "widzą" tę samą wartość countdown z migawki.
Aktualizacja stanu na podstawie poprzedniego stanu
Aby rozwiązać problem migawek, React pozwala na przekazanie funkcji do funkcji aktualizującej stan. Ta funkcja otrzymuje poprzedni stan jako argument:
function RocketLauncher() {
const [countdown, setCountdown] = useState(10);
const decrementCountdown = () => {
// To zadziała poprawnie, nawet dla wielu aktualizacji
setCountdown(prevCount => prevCount - 1); // Bazuje na poprzedniej wartości
setCountdown(prevCount => prevCount - 1); // Bazuje na wyniku poprzedniej aktualizacji
};
return (
<div className="rocket-launcher">
<h2>Odliczanie do startu: {countdown}</h2>
<button onClick={decrementCountdown}>
Zmniejsz odliczanie
</button>
</div>
);
}Teraz, przy każdym kliknięciu przycisku, odliczanie zostanie zmniejszone o 2.
Aktualizacja obiektów w stanie
Przy aktualizacji obiektów w stanie, ważne jest, aby zawsze tworzyć nowy obiekt, a nie modyfikować istniejącego. Jest to zgodne z zasadą niemutowalności (immutability) w React:
function SpaceshipSystems() {
const [systems, setSystems] = useState({
engines: 'offline',
lifeSupportOutput: 100,
navigationStatus: 'calibrating',
shields: 85
});
const startEngines = () => {
// ŹLE - modyfikacja oryginalnego obiektu
// systems.engines = 'online';
// setSystems(systems);
// DOBRZE - tworzenie nowego obiektu
setSystems({
...systems, // kopiuje wszystkie istniejące właściwości
engines: 'online' // nadpisuje tylko tę, którą chcemy zmienić
});
};
return (
<div className="spaceship-systems">
<h2>Status systemów</h2>
<p>Silniki: {systems.engines}</p>
<p>System podtrzymywania życia: {systems.lifeSupportOutput}%</p>
<p>Nawigacja: {systems.navigationStatus}</p>
<p>Tarcze: {systems.shields}%</p>
<button onClick={startEngines}>
Uruchom silniki
</button>
</div>
);
}Aktualizacja tablic w stanie
Podobnie jak w przypadku obiektów, przy aktualizacji tablic również należy przestrzegać zasady niemutowalności:
function MissionLog() {
const [logs, setLogs] = useState([
{ id: 1, time: '08:00', message: 'Rozpoczęcie misji' }
]);
const addLog = () => {
const newLog = {
id: Math.max(0, ...logs.map(log => log.id)) + 1, // największe id + 1, więc po usunięciu wpisu się nie powtórzy
time: new Date().toLocaleTimeString(),
message: 'Nowy wpis w dzienniku'
};
// ŹLE - mutowanie oryginalnej tablicy
// logs.push(newLog);
// setLogs(logs);
// DOBRZE - tworzenie nowej tablicy
setLogs([...logs, newLog]); // dodawanie na koniec
// lub
// setLogs([newLog, ...logs]); // dodawanie na początek
};
const removeLog = (logId) => {
// Filtrowanie - tworzenie nowej tablicy bez usuwanego elementu
setLogs(logs.filter(log => log.id !== logId));
};
return (
<div className="mission-log">
<h2>Dziennik misji</h2>
<button onClick={addLog}>Dodaj nowy wpis</button>
<ul className="log-entries">
{logs.map(log => (
<li key={log.id}>
<span className="time">{log.time}</span>
<span className="message">{log.message}</span>
<button onClick={() => removeLog(log.id)}>Usuń</button>
</li>
))}
</ul>
</div>
);
}Te same operacje na tablicy - dodawanie, przełączanie wpisu i usuwanie - zobaczysz w działaniu w demo poniżej, razem z licznikiem (liczba), przełącznikiem (wartość logiczna) i polem tekstowym (tekst). Zwróć uwagę na ramkę na dole: useState wywołujemy tylko na najwyższym poziomie komponentu, nigdy w pętli, warunku ani funkcji zagnieżdżonej, bo React rozpoznaje kolejne stany po kolejności wywołań przy każdym renderze.
Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
// Prosty licznik - podstawa useState
function SimpleCounter() {
const [count, setCount] = useState(0);
return (
<div style={{
backgroundColor: '#252545',
padding: '20px',
borderRadius: '12px',
textAlign: 'center'
}}>
<h3 style={{ color: '#00d4ff', marginTop: 0 }}>Prosty licznik</h3>
<div style={{
fontSize: '48px',
fontWeight: 'bold',
margin: '20px 0',
color: count > 0 ? '#4caf50' : count < 0 ? '#f44336' : 'white'
}}>
{count}
</div>
<div style={{ display: 'flex', gap: '10px', justifyContent: 'center' }}>
<button
onClick={() => setCount(count - 1)}
style={{
padding: '10px 20px',
backgroundColor: '#f44336',
color: 'white',
border: 'none',
borderRadius: '8px',
cursor: 'pointer',
fontSize: '18px'
}}
>
-1
</button>
<button
onClick={() => setCount(0)}
style={{
padding: '10px 20px',
backgroundColor: '#666',
color: 'white',
border: 'none',
borderRadius: '8px',
cursor: 'pointer'
}}
>
Reset
</button>
<button
onClick={() => setCount(count + 1)}
style={{
padding: '10px 20px',
backgroundColor: '#4caf50',
color: 'white',
border: 'none',
borderRadius: '8px',
cursor: 'pointer',
fontSize: '18px'
}}
>
+1
</button>
</div>
</div>
);
}
// Przełącznik - stan logiczny (boolean)
function ToggleSwitch() {
const [isOn, setIsOn] = useState(false);
return (
<div style={{
backgroundColor: '#252545',
padding: '20px',
borderRadius: '12px',
textAlign: 'center'
}}>
<h3 style={{ color: '#00d4ff', marginTop: 0 }}>Przełącznik</h3>
<div
onClick={() => setIsOn(!isOn)}
style={{
width: '80px',
height: '40px',
backgroundColor: isOn ? '#4caf50' : '#666',
borderRadius: '20px',
cursor: 'pointer',
position: 'relative',
margin: '20px auto',
transition: 'background-color 0.3s'
}}
>
<div style={{
width: '32px',
height: '32px',
backgroundColor: 'white',
borderRadius: '50%',
position: 'absolute',
top: '4px',
left: isOn ? '44px' : '4px',
transition: 'left 0.3s'
}} />
</div>
<p style={{ color: '#ccc' }}>
Status: <strong style={{ color: isOn ? '#4caf50' : '#f44336' }}>
{isOn ? 'WŁĄCZONY' : 'WYŁĄCZONY'}
</strong>
</p>
</div>
);
}
// Pole tekstowe - stan tekstowy (string)
function TextInput() {
const [text, setText] = useState('');
return (
<div style={{
backgroundColor: '#252545',
padding: '20px',
borderRadius: '12px'
}}>
<h3 style={{ color: '#00d4ff', marginTop: 0 }}>Pole tekstowe</h3>
<input
type="text"
value={text}
onChange={(e) => setText(e.target.value)}
placeholder="Wpisz coś..."
style={{
width: '100%',
padding: '12px 15px',
border: '2px solid #444',
borderRadius: '8px',
backgroundColor: '#1a1a2e',
color: 'white',
fontSize: '16px',
boxSizing: 'border-box'
}}
/>
<p style={{ color: '#888', marginBottom: 0 }}>
Wpisano: <strong style={{ color: 'white' }}>{text || '(pusto)'}</strong>
{' '}({text.length} znaków)
</p>
</div>
);
}
// Lista - stan tablicowy (array)
function TodoList() {
const [todos, setTodos] = useState([
{ id: 1, text: 'Nauczyć się React', done: true },
{ id: 2, text: 'Zrozumieć useState', done: false },
{ id: 3, text: 'Stworzyć projekt', done: false }
]);
const [newTodo, setNewTodo] = useState('');
const addTodo = () => {
if (newTodo.trim()) {
setTodos([...todos, {
id: Date.now(),
text: newTodo,
done: false
}]);
setNewTodo('');
}
};
const toggleTodo = (id) => {
setTodos(todos.map(todo =>
todo.id === id ? { ...todo, done: !todo.done } : todo
));
};
const deleteTodo = (id) => {
setTodos(todos.filter(todo => todo.id !== id));
};
return (
<div style={{
backgroundColor: '#252545',
padding: '20px',
borderRadius: '12px'
}}>
<h3 style={{ color: '#00d4ff', marginTop: 0 }}>Lista zadań</h3>
<div style={{ display: 'flex', gap: '10px', marginBottom: '15px' }}>
<input
type="text"
value={newTodo}
onChange={(e) => setNewTodo(e.target.value)}
onKeyDown={(e) => e.key === 'Enter' && addTodo()}
placeholder="Nowe zadanie..."
style={{
flex: 1,
padding: '10px 15px',
border: '2px solid #444',
borderRadius: '8px',
backgroundColor: '#1a1a2e',
color: 'white'
}}
/>
<button
onClick={addTodo}
style={{
padding: '10px 20px',
backgroundColor: '#4caf50',
color: 'white',
border: 'none',
borderRadius: '8px',
cursor: 'pointer'
}}
>
Dodaj
</button>
</div>
<div style={{ display: 'flex', flexDirection: 'column', gap: '8px' }}>
{todos.map(todo => (
<div key={todo.id} style={{
display: 'flex',
alignItems: 'center',
gap: '10px',
padding: '10px 15px',
backgroundColor: '#1a1a2e',
borderRadius: '8px'
}}>
<input
type="checkbox"
checked={todo.done}
onChange={() => toggleTodo(todo.id)}
style={{ width: '20px', height: '20px', cursor: 'pointer' }}
/>
<span style={{
flex: 1,
textDecoration: todo.done ? 'line-through' : 'none',
color: todo.done ? '#666' : 'white'
}}>
{todo.text}
</span>
<button
onClick={() => deleteTodo(todo.id)}
style={{
padding: '5px 10px',
backgroundColor: '#f44336',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: 'pointer'
}}
>
×
</button>
</div>
))}
</div>
<p style={{ color: '#888', marginBottom: 0, marginTop: '10px' }}>
Ukończono: {todos.filter(t => t.done).length} / {todos.length}
</p>
</div>
);
}
export default function App() {
return (
<div style={{
fontFamily: 'Arial, sans-serif',
backgroundColor: '#0a0a1a',
minHeight: '100vh',
padding: '20px',
color: 'white'
}}>
<header style={{
textAlign: 'center',
marginBottom: '30px',
padding: '30px',
background: 'linear-gradient(135deg, #667eea 0%, #764ba2 100%)',
borderRadius: '16px'
}}>
<h1 style={{ margin: 0 }}>useState w React</h1>
<p style={{ margin: '10px 0 0 0', opacity: 0.9 }}>
Zarządzanie stanem komponentów
</p>
</header>
<div style={{
display: 'grid',
gridTemplateColumns: 'repeat(auto-fit, minmax(300px, 1fr))',
gap: '20px'
}}>
<SimpleCounter />
<ToggleSwitch />
<TextInput />
<TodoList />
</div>
<div style={{
backgroundColor: '#1a1a2e',
padding: '20px',
borderRadius: '12px',
marginTop: '30px'
}}>
<h3 style={{ color: '#ff9800', marginTop: 0 }}>Zasady useState:</h3>
<ul style={{ color: '#ccc', lineHeight: '1.8', paddingLeft: '20px' }}>
<li>Wywoływać tylko na <strong>górnym poziomie</strong> komponentu</li>
<li>Nie używać w pętlach, warunkach czy funkcjach zagnieżdżonych</li>
<li>Aktualizacja stanu powoduje <strong>ponowne renderowanie</strong></li>
<li>Stan jest <strong>izolowany</strong> dla każdej instancji komponentu</li>
</ul>
</div>
</div>
);
}Każdy z czterech paneli ma własny, niezależny stan: kliknięcie licznika nie zmienia listy zadań, bo każdy komponent przechowuje swój stan osobno.
Kiedy używać state?
Stan powinien być używany dla danych, które:
- Zmieniają się w czasie
- Wpływają na renderowanie komponentu
- Nie mogą być obliczone na podstawie props lub innego stanu
Nie wszystkie dane powinny być w stanie. Dobre pytania, które warto sobie zadać:
- Czy dane pochodzą od rodzica poprzez props? Jeśli tak, prawdopodobnie nie powinny być w stanie.
- Czy dane pozostają niezmienione w czasie? Jeśli tak, prawdopodobnie nie powinny być w stanie.
- Czy dane można obliczyć na podstawie istniejących props lub stanu? Jeśli tak, zdecydowanie nie powinny być w stanie.
Podsumowanie
Stan (state) jest kluczowym elementem komponentów React, który pozwala na:
- Przechowywanie danych specyficznych dla komponentu
- Zarządzanie danymi, które zmieniają się w czasie
- Tworzenie interaktywnych interfejsów użytkownika, które reagują na akcje użytkownika
W następnych sekcjach zobaczymy, jak obsługiwać zdarzenia w React i jak łączyć je z zarządzaniem stanem, aby tworzyć w pełni interaktywne aplikacje.
Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
function ControlPanel() {
const [fuel, setFuel] = useState(100);
const [speed, setSpeed] = useState(0);
const [shields, setShields] = useState(true);
return (
<div className="control-panel">
<h1>Panel sterowania statkiem kosmicznym</h1>
<div className="gauges">
<div className="gauge">
<h3>Paliwo</h3>
<div className="progress-bar">
<div
className="progress-fill fuel"
style={{ width: `${fuel}%` }}
>
{fuel}%
</div>
</div>
<button
onClick={() => setFuel(Math.max(0, fuel - 10))}
disabled={fuel <= 0}
>
Zwiększ ciąg (-10% paliwa)
</button>
</div>
<div className="gauge">
<h3>Prędkość</h3>
<p className="speed-display">{speed} km/s</p>
<div className="speed-controls">
<button onClick={() => setSpeed(speed + 1)}>
Przyspiesz (+1)
</button>
<button
onClick={() => setSpeed(Math.max(0, speed - 1))}
disabled={speed <= 0}
>
Zwolnij (-1)
</button>
</div>
</div>
<div className="gauge">
<h3>Tarcze</h3>
<p className={`shield-status ${shields ? 'active' : 'inactive'}`}>
{shields ? 'Włączone' : 'Wyłączone'}
</p>
<button onClick={() => setShields(!shields)}>
{shields ? 'Wyłącz tarcze' : 'Włącz tarcze'}
</button>
</div>
</div>
</div>
);
}
function App() {
return (
<div className="app">
<ControlPanel />
</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łóż składnię deklaracji stanu za pomocą useState: