Kurs JavaScript i React · Moduł 5: useEffect i własne hooki

Własne hooki (Custom Hooks) do efektów

5 min czytania ·
W tej lekcji6

W kosmicznej podróży przez React, wielokrotne pisanie tych samych wzorców useEffect w różnych komponentach to jak budowanie od zera identycznych systemów nawigacyjnych dla każdego statku we flocie. Custom Hooks pozwalają wyekstrahować powtarzalną logikę efektów do jednej, wielokrotnie używanej funkcji - jak stworzenie modułu napędowego, który można zainstalować w dowolnym statku.

Czym są Custom Hooks?

Custom Hook to zwykła funkcja JavaScript, której nazwa zaczyna się od use i która może wywoływać inne hooki (useState, useEffect, useRef itp.). Nie jest to żadna specjalna składnia Reacta - jedyną konwencją jest prefiks use.

// Custom Hook - wyekstrahowana logika
function useWindowSize() {
  const [size, setSize] = useState({
    width: window.innerWidth,
    height: window.innerHeight
  });

  useEffect(() => {
    const handleResize = () => {
      setSize({ width: window.innerWidth, height: window.innerHeight });
    };

    window.addEventListener('resize', handleResize);
    return () => window.removeEventListener('resize', handleResize);
  }, []);

  return size;
}

// Użycie w komponencie - czysto i prosto
function SpaceshipCockpit() {
  const { width, height } = useWindowSize();

  return (
    <p>
      Rozmiar ekranu kokpitu: {width} x {height}
    </p>
  );
}

Zauważ, że useWindowSize zawiera wewnątrz useState i useEffect z cleanup - cała logika jest zamknięta w jednym hooku, a komponent dostaje gotowy wynik.

useFetch - pobieranie danych

Jednym z najczęstszych custom hooków jest hook do pobierania danych. Zamiast powtarzać wzorzec loading/error/data w każdym komponencie, zamykamy go w useFetch:

function useFetch(url) {
  const [data, setData] = useState(null);
  const [isLoading, setIsLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    const controller = new AbortController();
    setIsLoading(true);
    setError(null);

    fetch(url, { signal: controller.signal })
      .then(response => {
        if (!response.ok) throw new Error('Błąd sieci');
        return response.json();
      })
      .then(data => {
        setData(data);
        setIsLoading(false);
      })
      .catch(err => {
        if (err.name !== 'AbortError') {
          setError(err.message);
          setIsLoading(false);
        }
      });

    // Cleanup - anuluj request przy odmontowaniu lub zmianie URL
    return () => controller.abort();
  }, [url]);

  return { data, isLoading, error };
}

Teraz każdy komponent potrzebujący danych z API może użyć jednej linii:

function CrewList() {
  const { data: crew, isLoading, error } = useFetch('/api/crew');

  if (isLoading) return <p>Ładowanie załogi...</p>;
  if (error) return <p>Błąd: {error}</p>;

  return (
    <ul>
      {crew.map(member => (
        <li key={member.id}>{member.name}</li>
      ))}
    </ul>
  );
}

function MissionLog() {
  const { data: missions, isLoading } = useFetch('/api/missions');

  if (isLoading) return <p>Ładowanie misji...</p>;

  return missions.map(m => <div key={m.id}>{m.name}</div>);
}

Dwa komponenty, ten sam wzorzec pobierania danych - zero duplikacji kodu.

useInterval - bezpieczny timer

Timer z setInterval wymaga cleanup i poprawnej obsługi zależności. Custom hook zamyka tę logikę:

function useInterval(callback, delay) {
  const savedCallback = useRef();

  // Zapamiętaj najnowszą wersję callback
  useEffect(() => {
    savedCallback.current = callback;
  }, [callback]);

  // Ustaw timer
  useEffect(() => {
    if (delay === null) return; // null = pauzuj timer

    const tick = () => savedCallback.current();
    const id = setInterval(tick, delay);
    return () => clearInterval(id);
  }, [delay]);
}

// Użycie
function MissionClock() {
  const [seconds, setSeconds] = useState(0);
  const [isRunning, setIsRunning] = useState(false);

  useInterval(() => {
    setSeconds(prev => prev + 1);
  }, isRunning ? 1000 : null); // null = pauzuj

  return (
    <div>
      <p>Czas misji: {seconds}s</p>
      <button onClick={() => setIsRunning(!isRunning)}>
        {isRunning ? 'Pauza' : 'Start'}
      </button>
    </div>
  );
}

Dzięki useRef dla callback, timer zawsze wywołuje najnowszą wersję funkcji bez konieczności restartowania interwału.

useLocalStorage - trwały stan

Hook synchronizujący stan z localStorage:

function useLocalStorage(key, initialValue) {
  const [storedValue, setStoredValue] = useState(() => {
    try {
      const item = window.localStorage.getItem(key);
      return item ? JSON.parse(item) : initialValue;
    } catch (error) {
      return initialValue;
    }
  });

  useEffect(() => {
    try {
      window.localStorage.setItem(key, JSON.stringify(storedValue));
    } catch (error) {
      console.error('Błąd zapisu do localStorage:', error);
    }
  }, [key, storedValue]);

  return [storedValue, setStoredValue];
}

// Użycie - działa jak useState, ale persystuje dane
function ShipSettings() {
  const [theme, setTheme] = useLocalStorage('theme', 'dark');
  const [volume, setVolume] = useLocalStorage('volume', 50);

  return (
    <div>
      <select value={theme} onChange={e => setTheme(e.target.value)}>
        <option value="dark">Ciemny</option>
        <option value="light">Jasny</option>
      </select>
      <input
        type="range"
        value={volume}
        onChange={e => setVolume(Number(e.target.value))}
      />
    </div>
  );
}

Po odświeżeniu strony ustawienia są zachowane - localStorage pamięta wartości między sesjami.

Zasady tworzenia Custom Hooks

  1. Nazwa zaczyna się od use - to nie jest opcjonalne. React wymaga tego prefiksu, aby móc sprawdzać reguły hooków
  2. Mogą wywoływać inne hooki - useState, useEffect, useRef, a nawet inne custom hooki
  3. Każde wywołanie ma własny stan - dwa komponenty używające tego samego hooka mają niezależne kopie stanu
  4. Zwracają to, czego potrzebuje komponent - mogą zwracać wartości, tablice, obiekty, funkcje
// Custom Hook z wieloma wartościami zwracanymi
function useToggle(initialValue = false) {
  const [value, setValue] = useState(initialValue);

  const toggle = () => setValue(prev => !prev);
  const setTrue = () => setValue(true);
  const setFalse = () => setValue(false);

  return { value, toggle, setTrue, setFalse };
}

// Użycie
function ShieldControl() {
  const shields = useToggle(false);

  return (
    <div>
      <p>Tarcze: {shields.value ? 'AKTYWNE' : 'WYŁĄCZONE'}</p>
      <button onClick={shields.toggle}>Przełącz</button>
      <button onClick={shields.setTrue}>Aktywuj</button>
      <button onClick={shields.setFalse}>Dezaktywuj</button>
    </div>
  );
}

Podsumowanie

Custom Hooks to jedno z najpotężniejszych narzędzi w React do organizacji kodu:

  1. Eliminują duplikację - powtarzalna logika efektów w jednym miejscu
  2. Poprawiają czytelność - komponenty stają się krótsze i bardziej deklaratywne
  3. Ułatwiają testowanie - logikę hooka można testować niezależnie od komponentu
  4. Są kompozycyjne - custom hooki mogą wywoływać inne custom hooki

Jak modułowe systemy statku kosmicznego - system nawigacyjny, system komunikacyjny, system obronny - każdy jest osobnym modułem (hookiem), który można zainstalować w dowolnym statku (komponencie).

Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useRef } from 'react';

// Custom Hook: useToggle
function useToggle(initialValue = false) {
  const [value, setValue] = useState(initialValue);
  const toggle = () => setValue(prev => !prev);
  const setTrue = () => setValue(true);
  const setFalse = () => setValue(false);
  return { value, toggle, setTrue, setFalse };
}

// Custom Hook: useInterval
function useInterval(callback, delay) {
  const savedCallback = useRef();

  useEffect(() => {
    savedCallback.current = callback;
  }, [callback]);

  useEffect(() => {
    if (delay === null) return;
    const tick = () => savedCallback.current();
    const id = setInterval(tick, delay);
    return () => clearInterval(id);
  }, [delay]);
}

// Custom Hook: useLocalStorage
function useLocalStorage(key, initialValue) {
  const [storedValue, setStoredValue] = useState(() => {
    try {
      const item = window.localStorage.getItem(key);
      return item ? JSON.parse(item) : initialValue;
    } catch {
      return initialValue;
    }
  });

  useEffect(() => {
    try {
      window.localStorage.setItem(key, JSON.stringify(storedValue));
    } catch (error) {
      console.error('Blad zapisu:', error);
    }
  }, [key, storedValue]);

  return [storedValue, setStoredValue];
}

// Demo 1: useToggle
function ShieldControls() {
  const shields = useToggle(false);
  const weapons = useToggle(false);
  const engines = useToggle(true);

  return (
    <div className="demo-card">
      <h2>useToggle</h2>
      <div className="system-row">
        <span>Tarcze</span>
        <span className={shields.value ? 'on' : 'off'}>{shields.value ? 'ON' : 'OFF'}</span>
        <button onClick={shields.toggle}>Przelacz</button>
      </div>
      <div className="system-row">
        <span>Uzbrojenie</span>
        <span className={weapons.value ? 'on' : 'off'}>{weapons.value ? 'ON' : 'OFF'}</span>
        <button onClick={weapons.toggle}>Przelacz</button>
      </div>
      <div className="system-row">
        <span>Silniki</span>
        <span className={engines.value ? 'on' : 'off'}>{engines.value ? 'ON' : 'OFF'}</span>
        <button onClick={engines.toggle}>Przelacz</button>
      </div>
    </div>
  );
}

// Demo 2: useInterval
function MissionClock() {
  const [seconds, setSeconds] = useState(0);
  const isRunning = useToggle(false);

  useInterval(() => {
    setSeconds(prev => prev + 1);
  }, isRunning.value ? 1000 : null);

  const mins = String(Math.floor(seconds / 60)).padStart(2, '0');
  const secs = String(seconds % 60).padStart(2, '0');

  return (
    <div className="demo-card">
      <h2>useInterval</h2>
      <div className="clock">{mins}:{secs}</div>
      <div className="clock-controls">
        <button onClick={isRunning.toggle}>
          {isRunning.value ? 'Pauza' : 'Start'}
        </button>
        <button onClick={() => { isRunning.setFalse(); setSeconds(0); }}>
          Reset
        </button>
      </div>
    </div>
  );
}

// Demo 3: useLocalStorage
function ShipSettings() {
  const [pilotName, setPilotName] = useLocalStorage('pilotName', '');
  const [theme, setTheme] = useLocalStorage('theme', 'dark');
  const [volume, setVolume] = useLocalStorage('volume', 50);

  return (
    <div className="demo-card">
      <h2>useLocalStorage</h2>
      <p className="hint">Dane przetrwaja odswiezenie strony!</p>
      <div className="setting">
        <label>Pilot:</label>
        <input
          value={pilotName}
          onChange={e => setPilotName(e.target.value)}
          placeholder="Wpisz imie..."
        />
      </div>
      <div className="setting">
        <label>Motyw:</label>
        <select value={theme} onChange={e => setTheme(e.target.value)}>
          <option value="dark">Ciemny</option>
          <option value="light">Jasny</option>
          <option value="blue">Kosmiczny</option>
        </select>
      </div>
      <div className="setting">
        <label>Glosnosc: {volume}%</label>
        <input
          type="range"
          min="0"
          max="100"
          value={volume}
          onChange={e => setVolume(Number(e.target.value))}
        />
      </div>
    </div>
  );
}

function App() {
  return (
    <div className="app">
      <h1>Custom Hooks - Modulowe systemy statku</h1>
      <div className="demos">
        <ShieldControls />
        <MissionClock />
        <ShipSettings />
      </div>
    </div>
  );
}

export default App;

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. Które z poniższych NIE jest typowym zastosowaniem useEffect?

  2. 2. Który hook React zastępuje metodę componentDidMount z komponentów klasowych?

Zadania praktyczne w grze

  • Edytor kodu

    Własny hook media query

  • Edytor kodu

    Monitorowanie stanu baterii

  1. Zadanie z kodemPraktyka: useMediaQuery
  2. PytanieTypowe zastosowania useEffect
  3. Zadanie z kodemPraktyka: Battery API
  4. PytanieMapowanie metod cyklu życia

Przydatne artykuły