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

Optymalizacja wydajności z useEffect

7 min czytania ·
W tej lekcji7

W kosmicznej podróży przez React, wydajność jest krytycznie ważna - podobnie jak zarządzanie zasobami na statku kosmicznym. Nieoptymalne wykorzystanie efektów ubocznych może prowadzić do nadmiernej liczby renderowań, marnotrawstwa zasobów i wolnej reakcji aplikacji. W tym module nauczymy się, jak optymalizować działanie useEffect, aby nasze aplikacje działały płynnie i efektywnie.

Problemy wydajnościowe z useEffect

Hook useEffect jest potężnym narzędziem, ale niewłaściwie używany może powodować różne problemy:

  1. Zbyt częste wykonywanie efektów - gdy zależności zmieniają się często lub są nieprawidłowo zdefiniowane
  2. Kosztowne operacje - gdy wewnątrz efektu wykonujemy złożone obliczenia lub manipulacje DOM
  3. Kaskadowe aktualizacje - gdy jeden efekt powoduje zmiany stanu, które wyzwalają kolejne efekty
  4. Niepotrzebne renderowania - gdy efekty aktualizują stan, mimo że dane się faktycznie nie zmieniły

Optymalizacja tablicy zależności

Tablica zależności w useEffect jest kluczem do optymalizacji - określa kiedy efekt powinien być ponownie wykonany.

Błąd 1: Zbyt wiele zależności

// Problematyczny kod
function AstronautTracker({ team }) {
  const [position, setPosition] = useState({ x: 0, y: 0 });
  const [status, setStatus] = useState('online');

  // Ten efekt będzie uruchamiany zbyt często
  useEffect(() => {
    console.log(`Śledzenie astronauty: ${team.leader}`);
    fetchAstronautPosition(team.leader).then(newPosition => {
      setPosition(newPosition);
    });
  }, [team, position, status]); // Zbędne zależności: position i status

  return <div>Pozycja lidera: {position.x}, {position.y}</div>;
}

Rozwiązanie: Używaj tylko niezbędnych zależności

// Poprawiony kod
function AstronautTracker({ team }) {
  const [position, setPosition] = useState({ x: 0, y: 0 });
  const [status, setStatus] = useState('online');

  // Efekt używa tylko potrzebnych zależności
  useEffect(() => {
    console.log(`Śledzenie astronauty: ${team.leader}`);
    fetchAstronautPosition(team.leader).then(newPosition => {
      setPosition(newPosition);
    });
  }, [team.leader]); // Tylko potrzebna zależność

  return <div>Pozycja lidera: {position.x}, {position.y}</div>;
}

Technika: Memoryzacja obiektów i funkcji

Obiekty i funkcje tworzone podczas renderowania są zawsze "nowe" z perspektywy porównywania zależności. Możemy to zoptymalizować za pomocą hooków useMemo i useCallback:

function SpaceshipDashboard() {
  // Bez optymalizacji - obiekt config jest tworzony na nowo przy każdym renderze
  const config = { speed: 10, fuel: 100 };

  // Z optymalizacją - obiekt config jest zapamiętany i reużyty
  const memoizedConfig = useMemo(() => ({ speed: 10, fuel: 100 }), []);

  // Bez optymalizacji - funkcja handleData jest tworzona na nowo przy każdym renderze
  const handleData = (data) => console.log(data);

  // Z optymalizacją - funkcja handleData jest zapamiętana i reużyta
  const memoizedHandleData = useCallback((data) => console.log(data), []);

  useEffect(() => {
    // Ten efekt będzie uruchamiany tylko raz
    const subscription = spaceApi.subscribe(memoizedConfig, memoizedHandleData);
    return () => subscription.unsubscribe();
  }, [memoizedConfig, memoizedHandleData]); // Zależności są stabilne

  return <div>Statek kosmiczny</div>;
}

Techniki optymalizacji kosztownych operacji

1. Debouncing i throttling

Gdy efekt reaguje na szybko zmieniające się wartości (np. input użytkownika), warto użyć debouncing lub throttling:

function SearchAsteroids({ query }) {
  const [results, setResults] = useState([]);
  const [debouncedQuery, setDebouncedQuery] = useState(query);

  // Debouncing zapytania - aktualizuje się nie częściej niż co 500ms
  useEffect(() => {
    const timeoutId = setTimeout(() => {
      setDebouncedQuery(query);
    }, 500);

    return () => clearTimeout(timeoutId);
  }, [query]);

  // Efekt wyszukiwania wykonuje się tylko gdy debouncedQuery się zmieni
  useEffect(() => {
    if (debouncedQuery) {
      searchAsteroids(debouncedQuery).then(setResults);
    }
  }, [debouncedQuery]);

  return (
    <div>
      <h2>Wyniki wyszukiwania</h2>
      <ul>
        {results.map(asteroid => (
          <li key={asteroid.id}>{asteroid.name}</li>
        ))}
      </ul>
    </div>
  );
}

2. Unikanie niepotrzebnych aktualizacji stanu

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

  useEffect(() => {
    let isMounted = true;

    fetchStationData(stationId).then(newData => {
      // Aktualizuj tylko jeśli komponent jest wciąż zamontowany
      if (isMounted) {
        // Aktualizuj tylko jeśli dane faktycznie się zmieniły
        if (JSON.stringify(data) !== JSON.stringify(newData)) {
          setData(newData);
        }
      }
    });

    return () => {
      isMounted = false;
    };
  }, [stationId]);

  return data ? <StationDisplay data={data} /> : <Loading />;
}

Optymalizacja efektów z danymi asynchronicznymi

Problem: Wyścigi (race conditions)

Gdy efekt wykonuje asynchroniczne operacje, może dojść do "wyścigów" - sytuacji, gdzie nowszy request zakończy się przed starszym:

// Problematyczny kod - podatny na wyścigi
function AsteroidDetails({ asteroidId }) {
  const [details, setDetails] = useState(null);

  useEffect(() => {
    fetchAsteroidDetails(asteroidId).then(response => {
      setDetails(response); // Możliwy wyścig, jeśli asteroidId zmieni się szybko
    });
  }, [asteroidId]);

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

Rozwiązanie: Anulowanie przestarzałych requestów

// Poprawiony kod - zabezpieczony przed wyścigami
function AsteroidDetails({ asteroidId }) {
  const [details, setDetails] = useState(null);

  useEffect(() => {
    let isCurrent = true;

    fetchAsteroidDetails(asteroidId).then(response => {
      // Aktualizuj stan tylko jeśli to wciąż aktualny request
      if (isCurrent) {
        setDetails(response);
      }
    });

    return () => {
      isCurrent = false; // Oznacz, że ten efekt nie jest już aktualny
    };
  }, [asteroidId]);

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

Technika zaawansowana: AbortController

Dla API, które wspierają AbortController (np. fetch), możemy faktycznie anulować trwające requesty:

function PlanetScanner({ sector }) {
  const [planets, setPlanets] = useState([]);
  const [loading, setLoading] = useState(false);

  useEffect(() => {
    setLoading(true);

    // Tworzenie kontrolera anulowania
    const controller = new AbortController();
    const signal = controller.signal;

    fetch(`https://api.space/planets?sector=${sector}`, { signal })
      .then(response => response.json())
      .then(data => {
        setPlanets(data);
        setLoading(false);
      })
      .catch(error => {
        if (error.name !== 'AbortError') {
          console.error('Błąd:', error);
          setLoading(false);
        }
      });

    // Funkcja czyszcząca anuluje request, jeśli efekt zostanie przerwany
    return () => {
      controller.abort();
    };
  }, [sector]);

  return (
    <div>
      {loading ? <Loading /> : (
        <PlanetsList planets={planets} />
      )}
    </div>
  );
}

Separacja logiki do własnych hooków

Jednym z najlepszych sposobów optymalizacji jest tworzenie własnych hooków, które enkapsulują złożoną logikę i mogą być reużyte między komponentami:

// Własny hook do pobierania i zarządzania danymi
function usePlanetData(planetId) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let isMounted = true;
    setLoading(true);

    fetchPlanetData(planetId)
      .then(result => {
        if (isMounted) {
          setData(result);
          setLoading(false);
        }
      })
      .catch(err => {
        if (isMounted) {
          setError(err);
          setLoading(false);
        }
      });

    return () => {
      isMounted = false;
    };
  }, [planetId]);

  return { data, loading, error };
}

// Korzystanie z własnego hooka
function PlanetProfile({ planetId }) {
  const { data, loading, error } = usePlanetData(planetId);

  if (loading) return <LoadingIndicator />;
  if (error) return <ErrorMessage error={error} />;

  return (
    <div>
      <h1>{data.name}</h1>
      <p>Średnica: {data.diameter} km</p>
      <p>Klimat: {data.climate}</p>
    </div>
  );
}

Używanie mechanizmu layoutEffect

W rzadkich przypadkach, gdy potrzebujesz wykonać pomiary DOM lub synchronizować się z układem strony przed renderowaniem, możesz użyć useLayoutEffect zamiast useEffect:

function CockpitInterface() {
  const [dimensions, setDimensions] = useState({ width: 0, height: 0 });
  const cockpitRef = useRef(null);

  // useLayoutEffect uruchamia się synchronicznie po wszystkich mutacjach DOM,
  // ale przed renderowaniem na ekranie
  useLayoutEffect(() => {
    if (cockpitRef.current) {
      const { width, height } = cockpitRef.current.getBoundingClientRect();
      setDimensions({ width, height });
    }
  }, []);

  return (
    <div ref={cockpitRef} className="cockpit">
      <ControlPanel width={dimensions.width} height={dimensions.height} />
    </div>
  );
}

Uwaga: useLayoutEffect blokuje renderowanie wizualne, więc powinien być używany oszczędnie i tylko gdy absolutnie konieczne.

Podsumowanie: Najlepsze praktyki optymalizacji useEffect

  1. Minimalizuj zależności - używaj tylko niezbędnych wartości w tablicy zależności
  2. Separuj efekty - zamiast jednego złożonego efektu, używaj kilku prostszych
  3. Memoryzuj zależności - używaj useMemo i useCallback dla obiektów i funkcji
  4. Używaj debouncing/throttling - dla szybko zmieniających się wartości
  5. Anuluj przestarzałe operacje asynchroniczne - unikaj wyścigów i wycieków pamięci
  6. Twórz własne hooki - enkapsuluj złożoną logikę w reużywalnych hookach
  7. Analizuj wzorce renderowania - używaj React DevTools do wykrywania nadmiarowych renderowań
  8. Unikaj nieskończonych pętli - zawsze upewnij się, że efekty nie powodują nieskończonych cykli aktualizacji

Stosując te techniki optymalizacji, twoja aplikacja React będzie działać efektywnie nawet przy złożonych operacjach i dużych zbiorach danych - podobnie jak dobrze zoptymalizowany statek kosmiczny może pokonywać ogromne odległości z minimalnym zużyciem zasobów.

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

// Demonstracja tablicy zależności
function DependencyArrayDemo() {
  const [count, setCount] = useState(0);
  const [name, setName] = useState('');
  const [logs, setLogs] = useState([]);

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

  // Effect bez zależności - uruchamia się przy każdym renderze
  const effectRuns = useRef(0);
  useEffect(() => {
    // Bez setState: zmiana stanu tutaj wywołałaby kolejny render i nieskończoną pętlę
    effectRuns.current += 1;
    console.log(`Effect BEZ tablicy zależności (${effectRuns.current})`);
  });

  // Effect z pustą tablicą - tylko przy montowaniu
  useEffect(() => {
    addLog('Effect z [] - tylko przy mount');
  }, []);

  // Effect z zależnością od count
  useEffect(() => {
    addLog(`Effect z [count] - count = ${count}`);
  }, [count]);

  // Effect z zależnością od name
  useEffect(() => {
    if (name) addLog(`Effect z [name] - name = "${name}"`);
  }, [name]);

  return (
    <div className="demo-card">
      <h2>Tablica zależności</h2>
      <div className="inputs">
        <button onClick={() => setCount(c => c + 1)}>
          Count: {count}
        </button>
        <input
          value={name}
          onChange={(e) => setName(e.target.value)}
          placeholder="Wpisz imię..."
        />
      </div>
      <div className="logs">
        {logs.map((log, i) => <div key={i}>{log}</div>)}
      </div>
    </div>
  );
}

// Optymalizacja fetch requestów
function OptimizedFetchDemo() {
  const [searchTerm, setSearchTerm] = useState('');
  const [results, setResults] = useState([]);
  const [loading, setLoading] = useState(false);
  const [fetchCount, setFetchCount] = useState(0);
  const abortControllerRef = useRef(null);

  // Debounced search z cleanup
  useEffect(() => {
    // Anuluj poprzednie żądanie
    if (abortControllerRef.current) {
      abortControllerRef.current.abort();
    }

    if (!searchTerm.trim()) {
      setResults([]);
      return;
    }

    // Debounce - czekaj 500ms przed wyszukaniem
    const timeoutId = setTimeout(() => {
      abortControllerRef.current = new AbortController();

      setLoading(true);
      setFetchCount(c => c + 1);

      // Symulacja API call
      setTimeout(() => {
        const mockResults = [
          `Planeta: ${searchTerm}-Prime`,
          `Gwiazda: ${searchTerm}-Alpha`,
          `Mgławica: ${searchTerm}-Nebula`,
        ];
        setResults(mockResults);
        setLoading(false);
      }, 500);
    }, 500);

    // Cleanup - anuluj timeout i żądanie
    return () => {
      clearTimeout(timeoutId);
      if (abortControllerRef.current) {
        abortControllerRef.current.abort();
      }
    };
  }, [searchTerm]);

  return (
    <div className="demo-card">
      <h2>Optymalizacja Fetch</h2>
      <div className="fetch-counter">
        Wykonanych zapytań: <span>{fetchCount}</span>
      </div>
      <input
        value={searchTerm}
        onChange={(e) => setSearchTerm(e.target.value)}
        placeholder="Szukaj obiektów kosmicznych..."
      />
      <div className="results">
        {loading ? (
          <div className="loading">Wyszukiwanie...</div>
        ) : results.length > 0 ? (
          results.map((result, i) => (
            <div key={i} className="result">{result}</div>
          ))
        ) : searchTerm ? (
          <div className="empty">Wpisz, aby wyszukać</div>
        ) : null}
      </div>
      <p className="hint">Debounce 500ms + AbortController</p>
    </div>
  );
}

// Unikanie nieskończonych pętli
function InfiniteLoopPreventionDemo() {
  const [data, setData] = useState({ count: 0 });
  const renderCount = useRef(0);
  const [safeMode, setSafeMode] = useState(true);

  // Zliczanie renderów
  renderCount.current += 1;

  // NIEBEZPIECZNE - spowodowałoby nieskończoną pętlę
  // useEffect(() => {
  //   setData({ count: data.count }); // Nowy obiekt = nowa referencja = re-render
  // }, [data]);

  // BEZPIECZNE - używamy callbacka
  const incrementSafe = useCallback(() => {
    setData(prev => ({ count: prev.count + 1 }));
  }, []);

  return (
    <div className="demo-card">
      <h2>Unikanie pętli</h2>
      <div className="stats">
        <div className="stat">
          <span className="label">Count:</span>
          <span className="value">{data.count}</span>
        </div>
        <div className="stat">
          <span className="label">Rendery:</span>
          <span className="value">{renderCount.current}</span>
        </div>
      </div>
      <button onClick={incrementSafe}>
        Bezpieczny increment (useCallback)
      </button>
      <p className="hint">
        Używaj funkcji aktualizującej zamiast bezpośredniej referencji
      </p>
    </div>
  );
}

// Optymalizacja z useRef zamiast state
function UseRefOptimizationDemo() {
  const [, forceRender] = useState(0);
  const clickCountRef = useRef(0);
  const renderCountRef = useRef(0);

  renderCountRef.current++;

  const handleClick = () => {
    clickCountRef.current++;
    // Nie powoduje re-renderu!
  };

  return (
    <div className="demo-card">
      <h2>useRef vs useState</h2>
      <div className="comparison">
        <div className="box">
          <h3>useRef (bez re-renderu)</h3>
          <p>Kliknięcia: {clickCountRef.current}</p>
          <button onClick={handleClick}>Kliknij (useRef)</button>
        </div>
        <div className="box">
          <h3>Rendery komponentu</h3>
          <p>Liczba: {renderCountRef.current}</p>
          <button onClick={() => forceRender(n => n + 1)}>
            Wymuś render
          </button>
        </div>
      </div>
      <p className="hint">
        useRef nie powoduje re-renderu przy zmianie wartości
      </p>
    </div>
  );
}

function App() {
  return (
    <div className="app">
      <h1>Optymalizacja useEffect</h1>
      <div className="demos">
        <DependencyArrayDemo />
        <OptimizedFetchDemo />
        <InfiniteLoopPreventionDemo />
        <UseRefOptimizationDemo />
      </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. Co powinna zwracać funkcja cleanup w useEffect?

  2. 2. Dlaczego umieszczenie obiektu bezpośrednio w tablicy zależności useEffect może powodować nieskończoną pętlę?

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

Zadania praktyczne w grze

  • Układanie w pionie

    Ułóż kolejność kroków renderowania React z useEffect:

  • Edytor kodu

    Hook zarządzania klatkami animacji

  • Edytor kodu

    Implementacja wyszukiwania z debounce

  • Edytor kodu

    Stwórz komponent TemperatureMonitor używający useEffect do symulowania odczytów temperatury co 2 sekundy.

  • Układanie w pionie

    Ułóż ewolucję optymalizacji event handling:

  • Edytor kodu

    Stwórz komponent CommunicationChannel z useEffect, który ustanawia połączenie i czyści przy unmount.

  • Klikanie w kolejności

    Ułóż cykl życia useEffect:

  • Edytor kodu

    Stwórz EarthCommunication używający useEffect do fetch danych z API i obsługi loading/error states.

  • Układanie w pionie

    Ułóż ścieżkę opanowania useEffect:

  • Edytor kodu

    Stwórz ColonySettings z useEffect do synchronizacji state z localStorage (theme, language, etc.).

  • Edytor kodu

    Stwórz ShipDashboard z useState dla paliwa/temperatury/silnika, useEffect z interwałem co 2s, oraz przyciskami do sterowania systemami

  1. Ułóż w kolejnościMoment uruchomienia useEffect
  2. PytanieWartość zwracana z cleanup w useEffect
  3. Zadanie z kodemPraktyka: requestAnimationFrame
  4. PytanieObiekt w tablicy zależności
  5. Zadanie z kodemPraktyka: Debouncing
  6. PytanieCleanup function w useEffect
  7. Zadanie z kodemPraktyka: Efekty uboczne
  8. Ułóż w kolejnościSortowanie pionowe: Optymalizacja obsługi zdarzeń
  9. Zadanie z kodemPraktyka: Cleanup w useEffect
  10. Kliknij w kolejnościSortowanie: Cykl życia useEffect
  11. PytanieHook useEffect dependencies
  12. Zadanie z kodemPraktyka: Pobieranie danych
  13. Ułóż w kolejnościSortowanie pionowe: useEffect mastery path
  14. Zadanie z kodemPraktyka: localStorage w React
  15. PytanieTestowanie stanu i zdarzeń
  16. Zadanie z kodemPraktyka: Ship Dashboard

Przydatne artykuły