Kurs JavaScript i React · Moduł 3: Stan i zdarzenia
Aktualizacja stanu - wzorce i pułapki
W tej lekcji8
Wyobraź sobie, że systemy nawigacyjne twojego statku kosmicznego działają na podstawie danych o stanie - prędkość, kurs, poziom paliwa. Każda aktualizacja tych parametrów musi być precyzyjna, bo nawet drobny błąd może wytrącić statek z orbity. W React aktualizacja stanu podlega podobnym zasadom - musisz znać wzorce bezpiecznej aktualizacji, aby twoja aplikacja działała przewidywalnie.
Aktualizacja funkcyjna vs bezpośrednia wartość
Gdy wywołujesz setState, masz dwie opcje. Pierwsza to przekazanie nowej wartości wprost:
setCount(count + 1);Druga to aktualizacja funkcyjna - przekazanie funkcji, która otrzymuje poprzednią wartość stanu:
setCount(prev => prev + 1);Dlaczego to ma znaczenie? React grupuje aktualizacje stanu (batching) i nie wykonuje ich natychmiast. Jeśli w jednym handlerze wywołasz setCount(count + 1) kilka razy, każde wywołanie zobaczy tę samą wartość count:
function FuelGauge() {
const [fuel, setFuel] = useState(50);
const handleTripleBoost = () => {
// Wszystkie trzy widzą tę samą wartość fuel!
// Wynik: fuel wzrośnie tylko o 10, nie o 30
setFuel(fuel + 10);
setFuel(fuel + 10);
setFuel(fuel + 10);
};
const handleTripleBoostCorrect = () => {
// Każde wywołanie otrzymuje aktualną wartość
// Wynik: fuel wzrośnie o 30
setFuel(prev => prev + 10);
setFuel(prev => prev + 10);
setFuel(prev => prev + 10);
};
return (
<div>
<p>Paliwo: {fuel}%</p>
<button onClick={handleTripleBoost}>Boost (błędny)</button>
<button onClick={handleTripleBoostCorrect}>Boost (poprawny)</button>
</div>
);
}Zasada: Zawsze używaj aktualizacji funkcyjnej (prev => ...), gdy nowa wartość zależy od poprzedniej.
Wiele zmiennych stanu vs jeden obiekt
Masz dwie strategie przechowywania stanu w komponencie. Pierwsza to oddzielne zmienne stanu:
function ShipDashboard() {
const [speed, setSpeed] = useState(0);
const [altitude, setAltitude] = useState(0);
const [heading, setHeading] = useState(0);
// Każda zmienna aktualizowana niezależnie
const accelerate = () => setSpeed(prev => prev + 10);
const climb = () => setAltitude(prev => prev + 100);
return (
<div>
<p>Prędkość: {speed} km/s | Wysokość: {altitude} km | Kurs: {heading}°</p>
<button onClick={accelerate}>Przyspiesz</button>
<button onClick={climb}>Wznieś się</button>
</div>
);
}Druga to stan w obiekcie - przydatna gdy dane są ze sobą powiązane:
function ShipDashboard() {
const [navigation, setNavigation] = useState({
speed: 0,
altitude: 0,
heading: 0
});
// WAŻNE: zawsze kopiuj cały obiekt operatorem spread!
const accelerate = () => {
setNavigation(prev => ({ ...prev, speed: prev.speed + 10 }));
};
return (
<div>
<p>Prędkość: {navigation.speed} km/s</p>
<button onClick={accelerate}>Przyspiesz</button>
</div>
);
}Kiedy co stosować?
- Oddzielne
useState- gdy wartości zmieniają się niezależnie od siebie - Obiekt w
useState- gdy wartości logicznie należą do jednej całości (np. formularz, pozycja x/y)
Najczęstsze błędy - mutacja stanu
W React stan jest niemutowalny (immutable). Nigdy nie modyfikuj stanu bezpośrednio - zawsze twórz nową kopię. To jak zasada bezpieczeństwa na statku kosmicznym: nie modyfikujesz dziennika pokładowego, tylko dopisujesz nowy wpis.
Błąd 1: push zamiast spread dla tablic
function MissionLog() {
const [logs, setLogs] = useState(["Start misji"]);
const addLog = (entry) => {
// BŁĄD: push mutuje istniejącą tablicę!
// React nie wykryje zmiany i nie przerenderuje komponentu
logs.push(entry);
setLogs(logs);
};
const addLogCorrect = (entry) => {
// Spread tworzy nową tablicę
setLogs(prev => [...prev, entry]);
};
return (
<div>
<button onClick={() => addLogCorrect("Nowy wpis")}>
Dodaj wpis
</button>
{logs.map((log, i) => <p key={i}>{log}</p>)}
</div>
);
}Błąd 2: bezpośrednia zmiana właściwości obiektu
function CrewMember() {
const [member, setMember] = useState({
name: "Kapitan Nova",
rank: "Kapitan",
missions: 12
});
const promote = () => {
// BŁĄD: bezpośrednia mutacja obiektu
member.rank = "Admirał";
setMember(member);
};
const promoteCorrect = () => {
// Tworzenie nowego obiektu z operatorem spread
setMember(prev => ({ ...prev, rank: "Admirał" }));
};
return (
<div>
<p>{member.name} - {member.rank}</p>
<button onClick={promoteCorrect}>Awansuj</button>
</div>
);
}Stale closures - pułapka zamknięć
Closure (domknięcie) to sytuacja, gdy funkcja "zapamiętuje" zmienne z momentu jej utworzenia. W React może to prowadzić do odczytu nieaktualnego stanu:
function CountdownTimer() {
const [seconds, setSeconds] = useState(10);
const [running, setRunning] = useState(false);
const startCountdown = () => {
// seconds jest "zamrożone" z chwili kliknięcia!
// Każdy interwał widzi tę samą wartość
setInterval(() => {
setSeconds(seconds - 1); // zawsze 10 - 1 = 9
}, 1000);
};
const startCountdownCorrect = () => {
setRunning(true);
// Aktualizacja funkcyjna zawsze używa aktualnej wartości
setInterval(() => {
setSeconds(prev => Math.max(prev - 1, 0));
}, 1000);
};
return (
<div>
<p>Odliczanie: {seconds}s</p>
<button onClick={startCountdownCorrect} disabled={running}>Start</button>
</div>
);
}Przycisk z disabled={running} nie pozwoli uruchomić drugiego interwału, a Math.max(prev - 1, 0) zatrzymuje licznik na zerze. Sam interwał działa jednak dalej, dopóki go nie zatrzymasz przez clearInterval - porządne sprzątanie timerów poznasz w module o efektach (useEffect).
Batching - grupowanie aktualizacji
React 18+ automatycznie grupuje (batchuje) wiele aktualizacji stanu w jednym event handlerze, wykonując tylko jeden re-render. To jak komputer pokładowy, który zbiera wszystkie raporty z czujników i aktualizuje wyświetlacz raz, zamiast odświeżać go po każdym czujniku:
function NavigationUpdate() {
const [position, setPosition] = useState({ x: 0, y: 0 });
const [velocity, setVelocity] = useState(0);
const [status, setStatus] = useState("idle");
const handleJump = () => {
// React grupuje te 3 aktualizacje w jeden render
setPosition({ x: 100, y: 200 });
setVelocity(9999);
setStatus("hyperjump");
// Komponent renderuje się JEDEN raz, nie trzy!
};
return (
<div>
<p>Pozycja: ({position.x}, {position.y})</p>
<p>Prędkość: {velocity} | Status: {status}</p>
<button onClick={handleJump}>Skok nadprzestrzenny</button>
</div>
);
}Praktyczne wzorce aktualizacji stanu
Oto kilka wzorców, które przyda ci się znać na pokładzie statku React:
// Usuwanie elementu z tablicy
setItems(prev => prev.filter(item => item.id !== idToRemove));
// Aktualizacja jednego elementu w tablicy
setItems(prev => prev.map(item =>
item.id === targetId ? { ...item, status: "done" } : item
));
// Toggle (przełączanie boolean)
setIsActive(prev => !prev);
// Dodanie elementu na początek tablicy
setMessages(prev => [newMessage, ...prev]);
// Inkrementacja z limitem
setFuel(prev => Math.min(prev + 10, 100));Leniwa inicjalizacja stanu
Wartość początkowa jest potrzebna tylko przy pierwszym renderze. Jeśli jednak w nawiasie useState wywołasz funkcję, wykona się ona przy każdym renderze, choć React użyje jej wyniku tylko za pierwszym razem:
// ŹLE - computeStarMap() liczy się przy każdym renderze
const [stars, setStars] = useState(computeStarMap());Przy kosztownym obliczeniu (np. wyznaczaniu mapy gwiazd z tysięcy punktów) przekaż samą funkcję - React wywoła ją tylko raz, przy pierwszym renderze:
// DOBRZE - funkcja inicjalizująca wykona się tylko przy pierwszym renderze
const [stars, setStars] = useState(() => computeStarMap());Przekazujesz funkcję (() => computeStarMap() albo samo computeStarMap), a nie jej wynik - React zapamięta wartość i przy kolejnych renderach nie będzie jej już liczył.
Podsumowanie
Aktualizacja stanu w React - kluczowe zasady:
- Aktualizacja funkcyjna (
prev => prev + 1) - używaj gdy nowa wartość zależy od poprzedniej - Nigdy nie mutuj stanu - zawsze twórz nowe tablice/obiekty (spread operator)
- Batching - React grupuje aktualizacje i renderuje komponent raz
- Stale closures - w callbackach i timerach używaj aktualizacji funkcyjnej
- Wiele useState vs obiekt - zależy od logicznego powiązania danych
- Leniwa inicjalizacja -
useState(() => obliczenie())liczy wartość początkową tylko raz
Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
function FuelManager() {
// Oddzielne zmienne stanu
const [fuel, setFuel] = useState(50);
const [oxygen, setOxygen] = useState(100);
// Stan jako obiekt
const [position, setPosition] = useState({ x: 0, y: 0, z: 0 });
// Stan jako tablica
const [logs, setLogs] = useState([
{ id: 1, message: 'System uruchomiony', time: '00:00' }
]);
const [newLog, setNewLog] = useState('');
// Aktualizacja funkcyjna (prev =>)
const boostFuel = () => {
setFuel(prev => Math.min(prev + 10, 100));
};
const consumeFuel = () => {
setFuel(prev => Math.max(prev - 15, 0));
};
// Aktualizacja obiektu z spread
const moveShip = (axis, delta) => {
setPosition(prev => ({ ...prev, [axis]: prev[axis] + delta }));
};
// Dodawanie do tablicy (spread, nie push!)
const addLog = () => {
if (!newLog.trim()) return;
const now = new Date().toLocaleTimeString().slice(0, 5);
setLogs(prev => [...prev, {
id: Date.now(),
message: newLog,
time: now
}]);
setNewLog('');
};
// Usuwanie z tablicy (filter)
const removeLog = (id) => {
setLogs(prev => prev.filter(log => log.id !== id));
};
// Triple boost - porównanie błędnego i poprawnego podejścia
const brokenTripleBoost = () => {
// fuel jest "zamrożone" - wszystkie 3 widzą tę samą wartość
setFuel(fuel + 5);
setFuel(fuel + 5);
setFuel(fuel + 5);
};
const correctTripleBoost = () => {
// Każde wywołanie widzi aktualną wartość
setFuel(prev => Math.min(prev + 5, 100));
setFuel(prev => Math.min(prev + 5, 100));
setFuel(prev => Math.min(prev + 5, 100));
};
return (
<div style={{ fontFamily: 'Arial, sans-serif', padding: '20px', maxWidth: '700px', margin: '0 auto' }}>
<h1 style={{ textAlign: 'center', color: '#667eea' }}>Wzorce aktualizacji stanu</h1>
{/* Sekcja paliwa */}
<div style={{ padding: '16px', marginBottom: '16px', backgroundColor: '#f0f4ff', borderRadius: '12px' }}>
<h3>Paliwo: {fuel}%</h3>
<div style={{ height: '20px', backgroundColor: '#ddd', borderRadius: '10px', overflow: 'hidden' }}>
<div style={{
height: '100%', width: fuel + '%',
backgroundColor: fuel > 30 ? '#4caf50' : '#f44336',
transition: 'width 0.3s'
}} />
</div>
<div style={{ marginTop: '10px', display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
<button onClick={boostFuel} style={btnStyle('#4caf50')}>+10 (funkcyjny)</button>
<button onClick={consumeFuel} style={btnStyle('#f44336')}>-15 (funkcyjny)</button>
<button onClick={brokenTripleBoost} style={btnStyle('#ff9800')}>3x +5 (błędny)</button>
<button onClick={correctTripleBoost} style={btnStyle('#2196f3')}>3x +5 (poprawny)</button>
</div>
</div>
{/* Sekcja pozycji (obiekt) */}
<div style={{ padding: '16px', marginBottom: '16px', backgroundColor: '#f0fff4', borderRadius: '12px' }}>
<h3>Pozycja statku (obiekt ze spread)</h3>
<p>X: {position.x} | Y: {position.y} | Z: {position.z}</p>
<div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
<button onClick={() => moveShip('x', 10)} style={btnStyle('#667eea')}>X +10</button>
<button onClick={() => moveShip('y', 10)} style={btnStyle('#667eea')}>Y +10</button>
<button onClick={() => moveShip('z', 10)} style={btnStyle('#667eea')}>Z +10</button>
<button onClick={() => setPosition({ x: 0, y: 0, z: 0 })} style={btnStyle('#999')}>Reset</button>
</div>
</div>
{/* Sekcja logów (tablica) */}
<div style={{ padding: '16px', backgroundColor: '#fff8f0', borderRadius: '12px' }}>
<h3>Dziennik pokładowy (tablica ze spread)</h3>
<div style={{ display: 'flex', gap: '8px', marginBottom: '12px' }}>
<input
value={newLog}
onChange={e => setNewLog(e.target.value)}
placeholder="Nowy wpis..."
style={{ flex: 1, padding: '8px', borderRadius: '8px', border: '1px solid #ddd' }}
/>
<button onClick={addLog} style={btnStyle('#ff9800')}>Dodaj</button>
</div>
{logs.map(log => (
<div key={log.id} style={{
display: 'flex', justifyContent: 'space-between', alignItems: 'center',
padding: '8px 12px', marginBottom: '6px', backgroundColor: '#fff',
borderRadius: '8px', border: '1px solid #eee'
}}>
<span><strong>[{log.time}]</strong> {log.message}</span>
<button onClick={() => removeLog(log.id)} style={{
background: 'none', border: 'none', color: '#f44336', cursor: 'pointer', fontSize: '16px'
}}>x</button>
</div>
))}
</div>
</div>
);
}
function btnStyle(bg) {
return {
padding: '8px 16px', backgroundColor: bg, color: 'white',
border: 'none', borderRadius: '8px', cursor: 'pointer', fontSize: '13px'
};
}
export default function App() {
return <FuelManager />;
}Pamiętaj: Stan w React to jak dziennik pokładowy twojego statku - nigdy go nie edytujesz, tylko tworzysz nowy wpis na podstawie poprzedniego!
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. Dlaczego przy wielokrotnym wywołaniu setState w jednym handlerze należy używać aktualizacji funkcyjnej (prev => prev + 1)?
2. Dlaczego poniższy kod jest błędny? const [items, setItems] = useState(['A', 'B']); items.push('C'); setItems(items);
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Uporządkuj, co się dzieje, gdy React grupuje (batching) wiele aktualizacji stanu: