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

Zaawansowane efekty - race conditions i debouncing

6 min czytania ·
W tej lekcji6

W poprzednim module nauczyłeś się podstaw optymalizacji useEffect: właściwego dobierania zależności, używania flag isCurrent do zapobiegania wyścigom i prostego debouncingu. Czas na zaawansowane techniki - jak prawdziwy oficer inżynieryjny na statku kosmicznym, musisz znać nie tylko podstawowe procedury, ale także protokoły awaryjne na wypadek najbardziej złożonych sytuacji.

AbortController - anulowanie requestów

Prosta flaga isCurrent ma wadę: request kontynuuje działanie w tle, zużywając zasoby sieciowe. Gdy użytkownik szybko przełącza się między stronami, w tle mogą działać dziesiątki bezużytecznych requestów. To jak wysyłanie sygnałów radiowych do stacji, z których już odleciałeś - marnujesz energię nadajnika.

AbortController to wbudowany mechanizm przeglądarki, który pozwala faktycznie anulować request HTTP, a nie tylko ignorować jego wynik.

function PlanetDetails({ planetId }) {
  const [planet, setPlanet] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    // Tworzymy kontroler do anulowania requestu
    const abortController = new AbortController();

    setLoading(true);
    setError(null);

    fetch(`/api/planets/${planetId}`, {
      signal: abortController.signal  // Przekazujemy sygnał do fetch
    })
      .then(res => res.json())
      .then(data => {
        setPlanet(data);
        setLoading(false);
      })
      .catch(err => {
        // AbortError oznacza, że request został celowo anulowany
        if (err.name !== 'AbortError') {
          setError(err.message);
          setLoading(false);
        }
        // Jeśli AbortError - nie robimy nic, bo komponent już nie istnieje
      });

    // Cleanup: anuluj request gdy planetId się zmieni lub komponent się odmontuje
    return () => abortController.abort();
  }, [planetId]);

  if (loading) return <p>Ładowanie danych planety...</p>;
  if (error) return <p>Błąd: {error}</p>;
  return <h2>{planet?.name}</h2>;
}

Kluczowa różnica: z flagą isCurrent request leci dalej w tle i zużywa transfer. Z AbortController przeglądarka naprawdę przerywa połączenie sieciowe. Przy dużych plikach lub wolnym połączeniu to ogromna oszczędność.

Race conditions - głębsza analiza

Race condition (wyścig) w kontekście React to sytuacja, gdzie wynik asynchronicznej operacji trafia do komponentu w niewłaściwym momencie. Wyobraź sobie: astronauta klika na planetę Mars, potem szybko na Jowisza. Request o Marsa leci 2 sekundy, o Jowisza 0.5 sekundy. Jowisz wraca pierwszy - poprawnie wyświetlamy Jowisza. Ale po 2 sekundach wraca Mars i nadpisuje dane Jowisza!

// PROBLEM: Race condition bez zabezpieczenia
function StarMap({ starId }) {
  const [star, setStar] = useState(null);

  useEffect(() => {
    // Każda zmiana starId uruchamia nowy fetch
    // Ale poprzedni fetch nadal działa w tle!
    fetchStarData(starId).then(data => {
      setStar(data); // Może nadpisać nowsze dane!
    });
  }, [starId]);

  return <div>{star?.name}</div>;
}

// ROZWIĄZANIE: AbortController eliminuje wyścig
function StarMap({ starId }) {
  const [star, setStar] = useState(null);

  useEffect(() => {
    const controller = new AbortController();

    fetchStarData(starId, { signal: controller.signal })
      .then(data => setStar(data))
      .catch(err => {
        if (err.name !== 'AbortError') console.error(err);
      });

    return () => controller.abort(); // Anuluj poprzedni request
  }, [starId]);

  return <div>{star?.name}</div>;
}

Stale closures - pułapka nieaktualnych wartości

Stale closure (nieaktualne domknięcie) to subtelny bug, który pojawia się, gdy callback wewnątrz useEffect "widzi" starą wersję zmiennej stanu. To jak czytanie wczorajszego raportu sensorów, myśląc że to dane bieżące.

// PROBLEM: Stale closure
function AsteroidCounter() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const timer = setInterval(() => {
      // Ta funkcja "widzi" count z momentu utworzenia timera = zawsze 0!
      setCount(count + 1); // Zawsze ustawia na 1, bo count = 0
    }, 1000);

    return () => clearInterval(timer);
  }, []); // Pusta tablica = efekt uruchomiony raz, count zamknięty na 0

  return <p>Asteroidy: {count}</p>;
}

// ROZWIĄZANIE 1: Użyj functional updater
function AsteroidCounter() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const timer = setInterval(() => {
      // Functional updater zawsze otrzymuje aktualną wartość!
      setCount(prevCount => prevCount + 1);
    }, 1000);

    return () => clearInterval(timer);
  }, []);

  return <p>Asteroidy: {count}</p>;
}

// ROZWIĄZANIE 2: Użyj useRef dla wartości, które muszą być aktualne
function TrajectoryCalculator() {
  const [velocity, setVelocity] = useState(100);
  const velocityRef = useRef(velocity);

  // Synchronizuj ref z najnowszą wartością
  useEffect(() => {
    velocityRef.current = velocity;
  }, [velocity]);

  useEffect(() => {
    const timer = setInterval(() => {
      // ref.current zawsze ma najnowszą wartość
      console.log('Aktualna prędkość:', velocityRef.current);
    }, 1000);

    return () => clearInterval(timer);
  }, []);

  return <input value={velocity} onChange={e => setVelocity(Number(e.target.value))} />;
}

Reguła: Jeśli callback w setInterval lub setTimeout potrzebuje aktualnej wartości stanu, użyj functional updater (setState(prev => ...)) lub useRef.

Zaawansowane wzorce cleanup

Cleanup function w useEffect to nie tylko clearInterval. W prawdziwych aplikacjach musisz czyścić wiele rodzajów zasobów jednocześnie.

function LiveDashboard({ stationId }) {
  const [data, setData] = useState(null);

  useEffect(() => {
    const controller = new AbortController();
    let eventSource = null;
    let reconnectTimer = null;

    // 1. Fetch danych początkowych
    fetch(`/api/station/${stationId}`, { signal: controller.signal })
      .then(res => res.json())
      .then(setData)
      .catch(err => {
        if (err.name !== 'AbortError') console.error(err);
      });

    // 2. Server-Sent Events dla aktualizacji na żywo
    function connectSSE() {
      eventSource = new EventSource(`/api/station/${stationId}/live`);
      eventSource.onmessage = (event) => {
        setData(JSON.parse(event.data));
      };
      eventSource.onerror = () => {
        eventSource.close();
        // Ponowne połączenie po 5 sekundach
        reconnectTimer = setTimeout(connectSSE, 5000);
      };
    }
    connectSSE();

    // 3. Cleanup: zamknij WSZYSTKIE zasoby
    return () => {
      controller.abort();              // Anuluj fetch
      if (eventSource) eventSource.close();  // Zamknij SSE
      if (reconnectTimer) clearTimeout(reconnectTimer); // Anuluj reconnect
    };
  }, [stationId]);

  return <div>{data?.status}</div>;
}

Debounce z cleanup - prawidłowy wzorzec

W poprzednim module poznałeś prosty debouncing. Teraz zobaczmy wzorzec, który poprawnie obsługuje cleanup i unika wycieków pamięci:

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

  useEffect(() => {
    // Ustaw timer na aktualizację zdebouncowanej wartości
    const timer = setTimeout(() => {
      setDebouncedValue(value);
    }, delay);

    // Cleanup: anuluj timer jeśli value zmieni się przed upływem delay
    return () => clearTimeout(timer);
  }, [value, delay]);

  return debouncedValue;
}

// Użycie w komponencie wyszukiwarki
function GalaxySearch() {
  const [query, setQuery] = useState('');
  const debouncedQuery = useDebounce(query, 400);
  const [results, setResults] = useState([]);

  // Ten efekt uruchamia się dopiero po 400ms od ostatniego znaku
  useEffect(() => {
    if (!debouncedQuery) {
      setResults([]);
      return;
    }

    const controller = new AbortController();

    fetch(`/api/search?q=${debouncedQuery}`, { signal: controller.signal })
      .then(res => res.json())
      .then(setResults)
      .catch(err => {
        if (err.name !== 'AbortError') console.error(err);
      });

    return () => controller.abort();
  }, [debouncedQuery]);

  return (
    <div>
      <input value={query} onChange={e => setQuery(e.target.value)} placeholder="Szukaj w galaktyce..." />
      <ul>
        {results.map(r => <li key={r.id}>{r.name}</li>)}
      </ul>
    </div>
  );
}

Zauważ, jak łączymy trzy wzorce: custom hook (useDebounce), AbortController i cleanup. To typowy wzorzec w profesjonalnych aplikacjach React.

Podsumowanie

Zaawansowane techniki zarządzania efektami:

  1. AbortController - anuluj requesty zamiast ignorować odpowiedzi. Oszczędza transfer i zasoby.
  2. Race conditions - używaj AbortController lub flag cancel, aby zapobiec nadpisaniu nowszych danych starszymi.
  3. Stale closures - używaj functional updater (setState(prev => ...)) lub useRef w callbackach timerów.
  4. Złożony cleanup - zamykaj wszystkie zasoby: fetch, SSE, timery, event listenery.
  5. Debounce + AbortController - łącz oba wzorce dla optymalnego wyszukiwania.
Kod do tej lekcji: App.jsx
import React, { useState, useEffect, useRef, useCallback } from 'react';

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

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

  return debouncedValue;
}

// === Demo 1: AbortController ===
function AbortControllerDemo() {
  const [planetId, setPlanetId] = useState(1);
  const [planet, setPlanet] = useState(null);
  const [loading, setLoading] = useState(false);
  const [log, setLog] = useState([]);

  const addLog = useCallback((msg) => {
    setLog(prev => [...prev.slice(-6), `[${new Date().toLocaleTimeString()}] ${msg}`]);
  }, []);

  useEffect(() => {
    const controller = new AbortController();
    setLoading(true);
    addLog(`Fetch planety #${planetId} - START`);

    // Symulacja fetch z AbortController
    const timer = setTimeout(() => {
      if (!controller.signal.aborted) {
        const planets = ['Merkury','Wenus','Ziemia','Mars','Jowisz','Saturn','Uran','Neptun'];
        setPlanet({ id: planetId, name: planets[(planetId - 1) % planets.length] });
        setLoading(false);
        addLog(`Fetch planety #${planetId} - OK`);
      }
    }, 800 + Math.random() * 1200);

    return () => {
      controller.abort();
      clearTimeout(timer);
      addLog(`Fetch planety #${planetId} - ANULOWANY`);
    };
  }, [planetId, addLog]);

  return (
    <div className="demo-card">
      <h2>AbortController</h2>
      <p className="info">Klikaj szybko - zobacz anulowanie!</p>
      <div className="controls-row">
        {[1,2,3,4,5].map(id => (
          <button key={id}
            className={planetId === id ? 'active' : ''}
            onClick={() => setPlanetId(id)}>
            #{id}
          </button>
        ))}
      </div>
      <div className="result">
        {loading ? 'Ładowanie...' : planet ? `Planeta: ${planet.name}` : 'Wybierz planetę'}
      </div>
      <div className="log">
        {log.map((l, i) => (
          <div key={i} className={l.includes('ANULOWANY') ? 'log-abort' : l.includes('OK') ? 'log-ok' : 'log-start'}>
            {l}
          </div>
        ))}
      </div>
    </div>
  );
}

// === Demo 2: Stale Closure ===
function StaleClosureDemo() {
  const [count, setCount] = useState(0);
  const [badCount, setBadCount] = useState(0);
  const [running, setRunning] = useState(false);

  // BUG: stale closure - count zamknięty na 0
  useEffect(() => {
    if (!running) return;
    const timer = setInterval(() => {
      setBadCount(badCount + 1); // Zawsze widzi badCount=0!
    }, 500);
    return () => clearInterval(timer);
  }, [running]); // badCount nie w zależnościach = stale closure

  // FIX: functional updater
  useEffect(() => {
    if (!running) return;
    const timer = setInterval(() => {
      setCount(prev => prev + 1); // Zawsze aktualna wartość!
    }, 500);
    return () => clearInterval(timer);
  }, [running]);

  const reset = () => {
    setRunning(false);
    setCount(0);
    setBadCount(0);
  };

  return (
    <div className="demo-card">
      <h2>Stale Closure</h2>
      <div className="comparison">
        <div className="bad">
          <h3>BUG: count + 1</h3>
          <div className="big-number">{badCount}</div>
          <p>Zamrożony na 1!</p>
        </div>
        <div className="good">
          <h3>FIX: prev =&gt; prev + 1</h3>
          <div className="big-number">{count}</div>
          <p>Rośnie poprawnie!</p>
        </div>
      </div>
      <div className="controls-row">
        <button onClick={() => setRunning(true)} disabled={running}>Start</button>
        <button onClick={reset}>Reset</button>
      </div>
    </div>
  );
}

// === Demo 3: Debounce + AbortController ===
function DebouncedSearchDemo() {
  const [query, setQuery] = useState('');
  const debouncedQuery = useDebounce(query, 400);
  const [results, setResults] = useState([]);
  const [searchCount, setSearchCount] = useState(0);
  const [keystrokeCount, setKeystrokeCount] = useState(0);

  useEffect(() => {
    if (!debouncedQuery) {
      setResults([]);
      return;
    }

    const controller = new AbortController();
    setSearchCount(c => c + 1);

    // Symulacja wyszukiwania
    const stars = [
      'Syriusz', 'Betelgeza', 'Rigel', 'Vega', 'Altair',
      'Deneb', 'Polaris', 'Antares', 'Aldebaran', 'Spica',
      'Procjon', 'Akhernar', 'Kapella', 'Arktur', 'Kanopus'
    ];

    const timer = setTimeout(() => {
      if (!controller.signal.aborted) {
        const filtered = stars.filter(s =>
          s.toLowerCase().includes(debouncedQuery.toLowerCase())
        );
        setResults(filtered);
      }
    }, 200);

    return () => {
      controller.abort();
      clearTimeout(timer);
    };
  }, [debouncedQuery]);

  const handleInput = (e) => {
    setQuery(e.target.value);
    setKeystrokeCount(c => c + 1);
  };

  return (
    <div className="demo-card">
      <h2>Debounce + Abort</h2>
      <input
        className="search-input"
        placeholder="Szukaj gwiazdy (np. Syr, Bet, Rig)..."
        value={query}
        onChange={handleInput}
      />
      <div className="stats-row">
        <span>Klawisze: {keystrokeCount}</span>
        <span>Requesty: {searchCount}</span>
        <span>Zaoszczędzone: {Math.max(0, keystrokeCount - searchCount)}</span>
      </div>
      {results.length > 0 && (
        <div className="results">
          {results.map(r => <div key={r} className="result-item">{r}</div>)}
        </div>
      )}
      {debouncedQuery && results.length === 0 && (
        <p className="no-results">Brak wyników dla "{debouncedQuery}"</p>
      )}
    </div>
  );
}

function App() {
  return (
    <div className="app">
      <h1>Zaawansowane Efekty</h1>
      <div className="demos">
        <AbortControllerDemo />
        <StaleClosureDemo />
        <DebouncedSearchDemo />
      </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óry z poniższych zasobów wymaga cleanup function w useEffect?

  2. 2. Jak zapobiec race conditions przy pobieraniu danych w useEffect (np. szybkie przełączanie między stronami)?

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

Zadania praktyczne w grze

  • Klikanie w kolejności

    Uporządkuj setup event listenera:

  • Układanie w pionie

    Ułóż kolejność wykonywania hooków podczas renderowania:

  • Klikanie w kolejności

    Ułóż cleanup function dla timera w useEffect:

  • Układanie w pionie

    Uporządkuj kroki zapobiegania wyciekom pamięci w useEffect - od identyfikacji do rozwiązania:

  • Klikanie w kolejności

    Uporządkuj custom hook:

  • Klikanie w kolejności

    Ułóż wzorzec wywołania async w useEffect:

  • Układanie w pionie

    Ułóż kroki obsługi fetch z AbortController w useEffect:

  • Układanie w pionie

    Uporządkuj cykl życia efektu z cleanup przy zmianie zależności:

  • Układanie w poziomie

    Ułóż elementy deklaracji custom hooka od lewej do prawej:

  • Układanie w pionie

    Uporządkuj cykl życia efektu w useEffect:

  1. Kliknij w kolejnościEvent listener setup
  2. Ułóż w kolejnościuseLayoutEffect
  3. PytanieStrategie czyszczenia efektów
  4. PytanieRace conditions w useEffect
  5. Kliknij w kolejnościCzyszczenie timera w useEffect
  6. PytanieOptymalizacje wydajności
  7. Ułóż w kolejnościWycieki pamięci a useEffect
  8. Kliknij w kolejnościWzorzec własnego hooka
  9. Kliknij w kolejnościAsync funkcje w useEffect
  10. PytanieuseRef w integracji z bibliotekami
  11. Ułóż w kolejnościAbortController w useEffect
  12. PytanieTestowanie cleanup w useEffect
  13. Ułóż w kolejnościCleanup function w useEffect
  14. PytanieTworzenie custom hooków
  15. Ułóż w kolejnościDeklaracja custom hooka
  16. Ułóż w kolejnościCykl życia useEffect
  17. PytanieWzorce kompozycji efektów

Przydatne artykuły