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

Tworzenie własnych hooków (Custom Hooks) - zaawansowane wzorce

6 min czytania ·
W tej lekcji7

W kosmicznej flocie React, jednym z najcenniejszych umiejętności inżyniera jest projektowanie modułów wielokrotnego użytku. Wyobraź sobie, że budujesz systemy nawigacyjne, komunikacyjne i diagnostyczne dla setek statków kosmicznych. Zamiast pisać każdy system od zera dla każdego statku, tworzysz uniwersalne moduły, które można podłączyć do dowolnego pojazdu. Dokładnie tak działają Custom Hooks w React.

W poprzedniej lekcji poznaliśmy podstawy custom hooków - useFetch, useInterval, useLocalStorage i useToggle. Teraz zagłębimy się w zaawansowane wzorce, reguły hooków i kompozycję, które uczynią Twoje hooki naprawdę profesjonalnymi.

Reguły Hooków (Rules of Hooks)

Zanim zaczniemy tworzyć zaawansowane hooki, musimy znać dwie fundamentalne reguły, których złamanie powoduje nieprzewidywalne błędy:

Reguła 1: Wywoływanie hooków tylko na najwyższym poziomie

Hooki muszą być wywoływane zawsze w tej samej kolejności przy każdym renderowaniu. Nigdy nie umieszczaj hooków wewnątrz warunków, pętli ani zagnieżdżonych funkcji:

// ŹLE - hook wewnątrz warunku
function SpaceShip({ hasRadar }) {
  if (hasRadar) {
    const [signal, setSignal] = useState(null); // BŁĄD!
  }
}

// DOBRZE - warunek wewnątrz hooka
function SpaceShip({ hasRadar }) {
  const [signal, setSignal] = useState(null);

  useEffect(() => {
    if (hasRadar) {
      // logika radaru
    }
  }, [hasRadar]);
}

React śledzi hooki na podstawie ich kolejności wywołania. Jeśli warunek spowoduje pominięcie jednego hooka, wszystkie następne będą miały błędne wartości - jak gdyby przesunęły się wszystkie moduły w statku kosmicznym.

Reguła 2: Wywoływanie hooków tylko z komponentów React lub custom hooków

Nie możesz wywoływać hooków z zwykłych funkcji JavaScript. Tylko:

  • Komponenty funkcyjne React
  • Custom Hooki (funkcje zaczynające się od use)
// ŹLE - zwykła funkcja
function calculateTrajectory() {
  const [speed] = useState(0); // BŁĄD!
}

// DOBRZE - custom hook
function useTrajectory() {
  const [speed, setSpeed] = useState(0);
  return { speed, setSpeed };
}

useDebounce - opóźnianie akcji

Hook useDebounce jest niezwykle przydatny do wyszukiwania w czasie rzeczywistym. Zamiast wysyłać zapytanie do API po każdym naciśnięciu klawisza, czekamy aż użytkownik skończy pisać:

function useDebounce(value, delay) {
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    const timer = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    return () => clearTimeout(timer);
  }, [value, delay]);

  return debouncedValue;
}

// Użycie - wyszukiwanie planet
function PlanetSearch() {
  const [query, setQuery] = useState('');
  const debouncedQuery = useDebounce(query, 500);

  useEffect(() => {
    if (debouncedQuery) {
      // Zapytanie wysyłane dopiero po 500ms przerwy w pisaniu
      fetch(`/api/planets?search=${debouncedQuery}`);
    }
  }, [debouncedQuery]);

  return (
    <input
      value={query}
      onChange={e => setQuery(e.target.value)}
      placeholder="Szukaj planet..."
    />
  );
}

Timer jest czyszczony przy każdej zmianie wartości. Dopiero gdy użytkownik przestanie pisać na 500ms, wartość zostanie zaktualizowana i zapytanie API wysłane.

usePrevious - zapamiętywanie poprzedniej wartości

Ten prosty hook pozwala porównywać aktualną wartość z poprzednią:

function usePrevious(value) {
  const ref = useRef();

  useEffect(() => {
    ref.current = value;
  }, [value]);

  return ref.current;
}

// Użycie - monitorowanie zmian prędkości
function SpeedMonitor() {
  const [speed, setSpeed] = useState(0);
  const previousSpeed = usePrevious(speed);

  const trend = speed > previousSpeed
    ? 'Przyspieszanie'
    : speed < previousSpeed
    ? 'Hamowanie'
    : 'Stała prędkość';

  return <p>{trend}: {speed} km/s (było: {previousSpeed})</p>;
}

useArray - zarządzanie tablicami

Tablice wymagają specyficznych operacji (dodawanie, usuwanie, filtrowanie). Custom hook zamyka te operacje w czytelny interfejs:

function useArray(initialArray = []) {
  const [array, setArray] = useState(initialArray);

  const push = (element) => setArray(a => [...a, element]);
  const removeByIndex = (index) =>
    setArray(a => a.filter((_, i) => i !== index));
  const update = (index, newElement) =>
    setArray(a => a.map((item, i) => (i === index ? newElement : item)));
  const clear = () => setArray([]);
  const filter = (fn) => setArray(a => a.filter(fn));

  return { array, set: setArray, push, removeByIndex, update, clear, filter };
}

// Użycie - lista załogantów
function CrewManager() {
  const crew = useArray(['Kapitan Nova', 'Nawigator Rex']);

  return (
    <div>
      {crew.array.map((member, i) => (
        <div key={i}>
          {member}
          <button onClick={() => crew.removeByIndex(i)}>Usuń</button>
        </div>
      ))}
      <button onClick={() => crew.push('Nowy członek')}>
        Dodaj członka załogi
      </button>
      <button onClick={crew.clear}>Zwolnij załogę</button>
    </div>
  );
}

Kompozycja hooków - łączenie modułów

Prawdziwa siła custom hooków ujawnia się, gdy łączymy je ze sobą. Hooki mogą wywoływać inne hooki, tworząc złożone zachowania z prostych bloków:

// Hook 1: Prosty hook stanu z walidacją
function useValidatedInput(initialValue, validator) {
  const [value, setValue] = useState(initialValue);
  const [error, setError] = useState(null);

  const handleChange = (newValue) => {
    setValue(newValue);
    const validationError = validator(newValue);
    setError(validationError);
  };

  return { value, error, onChange: handleChange, isValid: !error };
}

// Hook 2: Kompozycja - formularz z wieloma polami
function useSpaceshipForm() {
  const name = useValidatedInput('', (v) =>
    v.length < 3 ? 'Min. 3 znaki' : null
  );
  const fuel = useValidatedInput(100, (v) =>
    v < 0 || v > 100 ? 'Zakres 0-100' : null
  );

  const isFormValid = name.isValid && fuel.isValid;

  const reset = () => {
    name.onChange('');
    fuel.onChange(100);
  };

  return { name, fuel, isFormValid, reset };
}

// Użycie
function ShipRegistration() {
  const form = useSpaceshipForm();

  return (
    <form>
      <input
        value={form.name.value}
        onChange={e => form.name.onChange(e.target.value)}
      />
      {form.name.error && <span>{form.name.error}</span>}

      <input
        type="number"
        value={form.fuel.value}
        onChange={e => form.fuel.onChange(Number(e.target.value))}
      />
      {form.fuel.error && <span>{form.fuel.error}</span>}

      <button disabled={!form.isFormValid}>Zarejestruj statek</button>
    </form>
  );
}

useSpaceshipForm używa useValidatedInput dwukrotnie - każde wywołanie tworzy niezależną instancję ze swoim stanem.

Wzorzec: useToggle, useCounter, useForm

Popularne wzorce custom hooków, które warto znać:

HookZastosowanieZwraca
useTogglePrzełącznik on/off{ value, toggle, setTrue, setFalse }
useCounterLicznik z min/max{ count, increment, decrement, reset }
useFetchPobieranie danych{ data, loading, error, refetch }
useDebounceOpóźnianie wartościOpóźniona wartość
usePreviousPoprzednia wartośćPoprzednia wartość
useArrayOperacje na tablicach{ array, push, remove, update, clear }
useLocalStoragePersystentny stan[value, setValue]

Podsumowanie

Custom Hooks to fundament dobrze zorganizowanej aplikacji React:

  1. Reguły hooków - zawsze na najwyższym poziomie, tylko w komponentach i hookach
  2. Prefiks use - obowiązkowy, pozwala Reactowi weryfikować reguły
  3. Kompozycja - hooki mogą wywoływać inne hooki, budując złożone zachowania
  4. Niezależne instancje - każde wywołanie hooka ma własny, izolowany stan
  5. Reużywalność - jedna logika, wiele komponentów

Jak modułowe systemy kosmicznego statku - każdy hook to samodzielny moduł, który można zainstalować, skonfigurować i połączyć z innymi modułami w dowolnej konfiguracji.

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

// === useDebounce ===
function useDebounce(value, delay) {
  const [debouncedValue, setDebouncedValue] = useState(value);

  useEffect(() => {
    const timer = setTimeout(() => setDebouncedValue(value), delay);
    return () => clearTimeout(timer);
  }, [value, delay]);

  return debouncedValue;
}

// === usePrevious ===
function usePrevious(value) {
  const ref = useRef();
  useEffect(() => { ref.current = value; }, [value]);
  return ref.current;
}

// === useToggle ===
function useToggle(initial = false) {
  const [value, setValue] = useState(initial);
  const toggle = () => setValue(v => !v);
  const setTrue = () => setValue(true);
  const setFalse = () => setValue(false);
  return { value, toggle, setTrue, setFalse };
}

// === useArray ===
function useArray(initialArray = []) {
  const [array, setArray] = useState(initialArray);
  const push = (el) => setArray(a => [...a, el]);
  const removeByIndex = (i) => setArray(a => a.filter((_, idx) => idx !== i));
  const clear = () => setArray([]);
  return { array, push, removeByIndex, clear, set: setArray };
}

// === 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 (e) { console.error(e); }
  }, [key, storedValue]);

  return [storedValue, setStoredValue];
}

// --- Demo Components ---

function DebounceDemo() {
  const [text, setText] = useState('');
  const debouncedText = useDebounce(text, 600);
  const [results, setResults] = useState([]);

  useEffect(() => {
    if (debouncedText) {
      const planets = ['Merkury','Wenus','Ziemia','Mars','Jowisz','Saturn','Uran','Neptun'];
      setResults(planets.filter(p =>
        p.toLowerCase().includes(debouncedText.toLowerCase())
      ));
    } else {
      setResults([]);
    }
  }, [debouncedText]);

  return (
    <div className="demo-card">
      <h3>useDebounce</h3>
      <input value={text} onChange={e => setText(e.target.value)} placeholder="Szukaj planet..." />
      <p className="hint">Debounced: "{debouncedText}"</p>
      {results.length > 0 && (
        <ul className="results">{results.map(r => <li key={r}>{r}</li>)}</ul>
      )}
    </div>
  );
}

function PreviousDemo() {
  const [speed, setSpeed] = useState(0);
  const prevSpeed = usePrevious(speed);

  const trend = speed > (prevSpeed || 0) ? 'Przyspieszanie' :
                speed < (prevSpeed || 0) ? 'Hamowanie' : 'Stala predkosc';

  return (
    <div className="demo-card">
      <h3>usePrevious</h3>
      <p className="speed-display">{speed} km/s</p>
      <p className="hint">Poprzednio: {prevSpeed ?? 0} km/s | {trend}</p>
      <div className="btn-row">
        <button onClick={() => setSpeed(s => s + 10)}>+10</button>
        <button onClick={() => setSpeed(s => Math.max(0, s - 10))}>-10</button>
        <button onClick={() => setSpeed(0)}>Reset</button>
      </div>
    </div>
  );
}

function ToggleDemo() {
  const shields = useToggle(false);
  const engines = useToggle(true);

  return (
    <div className="demo-card">
      <h3>useToggle</h3>
      <div className="toggle-item">
        <span>Tarcze: <b style={{color: shields.value ? '#2ecc71' : '#e74c3c'}}>
          {shields.value ? 'AKTYWNE' : 'WYLACZONE'}
        </b></span>
        <button onClick={shields.toggle}>Przelacz</button>
      </div>
      <div className="toggle-item">
        <span>Silniki: <b style={{color: engines.value ? '#2ecc71' : '#e74c3c'}}>
          {engines.value ? 'AKTYWNE' : 'WYLACZONE'}
        </b></span>
        <button onClick={engines.toggle}>Przelacz</button>
      </div>
    </div>
  );
}

function ArrayDemo() {
  const crew = useArray(['Kapitan Nova', 'Nawigator Rex']);
  const [name, setName] = useState('');

  const addMember = () => {
    if (name.trim()) { crew.push(name.trim()); setName(''); }
  };

  return (
    <div className="demo-card">
      <h3>useArray</h3>
      <div className="crew-list">
        {crew.array.map((member, i) => (
          <div key={i} className="crew-member">
            <span>{member}</span>
            <button onClick={() => crew.removeByIndex(i)} className="btn-small">X</button>
          </div>
        ))}
      </div>
      <div className="add-row">
        <input value={name} onChange={e => setName(e.target.value)}
          placeholder="Imie czlonka zalogi..." onKeyDown={e => e.key === 'Enter' && addMember()} />
        <button onClick={addMember}>Dodaj</button>
      </div>
      <button onClick={crew.clear} className="btn-danger">Zwolnij zaloge</button>
    </div>
  );
}

function StorageDemo() {
  const [theme, setTheme] = useLocalStorage('space-theme', 'dark');
  const [volume, setVolume] = useLocalStorage('space-volume', 50);

  return (
    <div className="demo-card">
      <h3>useLocalStorage</h3>
      <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="cosmic">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>
      <p className="hint">Wartosci zapisywane w localStorage</p>
    </div>
  );
}

export default function App() {
  return (
    <div className="app">
      <h1>Custom Hooks - Moduly statku kosmicznego</h1>
      <div className="grid">
        <DebounceDemo />
        <PreviousDemo />
        <ToggleDemo />
        <ArrayDemo />
        <StorageDemo />
      </div>
    </div>
  );
}

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 NIE można wywoływać hooków wewnątrz instrukcji warunkowych (if/else)?

  2. 2. Czym custom hook różni się od zwykłej funkcji JavaScript?

To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Stwórz custom hook useDebounce(value, delay) zwracający opóźnioną wartość oraz useToggle(initialValue) zwracający { value, toggle, setTrue, setFalse }. Oba hooki powinny działać z komponentami testowymi na stronie.

  • Układanie w pionie

    Uporządkuj etapy tworzenia custom hooka od początku do końca:

  • Edytor kodu

    Stwórz custom hook useArray(initialArray) zwracający { array, set, push, removeByIndex, update, clear, filter } oraz usePrevious(value) zwracający poprzednią wartość. Hooki powinny działać z komponentem zarządzania załogą na stronie.

  • Klikanie w kolejności

    Ułóż składnię custom hooka useDebounce w poprawnej kolejności:

  • Edytor kodu

    Zbuduj kompleksowy Saturn Ring Observatory Control Panel zawierający: useEffect dla monitoring różnych faz orbitalnych pierścieni, useLayoutEffect dla synchronizacji pomiarów w czasie rzeczywistym, cleanup functions dla proper unmounting sensors, dependency arrays dla precyzyjnej kontroli re-runs, multiple effects dla niezależnych systemów monitoringu (RingA, RingB, RingC monitoring), effect optimization patterns, async effects dla data fetching z sond kosmicznych, oraz conditional effects reagujące na różne stany obserwatorium. Stwórz system monitoringu godny najbardziej zaawansowanego obserwatorium pierścieni Saturna!

  1. PytanieReguły hooków w React
  2. PytanieCustom hook vs funkcja JavaScript
  3. Zadanie z kodemPraktyka: useDebounce i useToggle
  4. PytanieStan w custom hookach
  5. Ułóż w kolejnościEtapy tworzenia custom hooka
  6. Zadanie z kodemPraktyka: useArray i usePrevious
  7. Kliknij w kolejnościSkładnia custom hooka useDebounce
  8. Zadanie z kodemProjekt: Saturn Ring Monitor
  9. Projekt do wysłaniaProjekt do mentora: Centrum Monitorowania Czasu
  10. WideoVideo: Podsumowanie modułu

Przydatne artykuły