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

Aktualizacja stanu - wzorce i pułapki

6 min czytania ·
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:

  1. Aktualizacja funkcyjna (prev => prev + 1) - używaj gdy nowa wartość zależy od poprzedniej
  2. Nigdy nie mutuj stanu - zawsze twórz nowe tablice/obiekty (spread operator)
  3. Batching - React grupuje aktualizacje i renderuje komponent raz
  4. Stale closures - w callbackach i timerach używaj aktualizacji funkcyjnej
  5. Wiele useState vs obiekt - zależy od logicznego powiązania danych
  6. 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. 1. Dlaczego przy wielokrotnym wywołaniu setState w jednym handlerze należy używać aktualizacji funkcyjnej (prev => prev + 1)?

  2. 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:

  1. PytanieAktualizacja funkcyjna setState
  2. PytanieMutacja stanu w React
  3. PytanieZatrzymanie propagacji - co pojawi się w konsoli?
  4. Ułóż w kolejnościProces batchingu aktualizacji stanu

Przydatne artykuły