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

Stan komponentu (State)

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

  1. Importujemy hook useState z Reacta
  2. Wywołujemy useState(100), aby stworzyć zmienną stanu fuel z wartością początkową 100
  3. Destrukturyzujemy wynik, aby uzyskać:
    • fuel: aktualną wartość stanu
    • setFuel: funkcję do aktualizacji tej wartości
  4. Używamy setFuel w 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:

  1. Zmieniają się w czasie
  2. Wpływają na renderowanie komponentu
  3. 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:

  1. Ułóż w kolejnościDeklaracja useState

Przydatne artykuły