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

Czyszczenie efektów

11 min czytania ·
W tej lekcji10

Poprawne czyszczenie efektów ubocznych jest kluczowym aspektem tworzenia niezawodnych aplikacji w React. Podobnie jak astronauci muszą czyścić swoje systemy podtrzymywania życia, aby uniknąć awarii, tak samo my musimy dbać o czyszczenie naszych efektów, aby uniknąć wycieków pamięci, niepotrzebnych obliczeń i innych problemów.

Dlaczego czyszczenie efektów jest ważne?

Gdy komponent jest odmontowywany (usuwany z DOM) lub gdy zmieniają się zależności efektu, mogą wystąpić różne problemy, jeśli nie zadbamy o właściwe czyszczenie:

  1. Wycieki pamięci - nieużywane zasoby, które nie są zwalniane
  2. Aktualizacja stanu odmontowanych komponentów - prowadzi do ostrzeżeń i błędów
  3. Niepotrzebne obliczenia - zużywanie zasobów na operacje, które nie są już potrzebne
  4. Kolidujące aktualizacje - gdy stare i nowe efekty działają jednocześnie
  5. Subskrypcje "duchów" - stare subskrypcje nadal reagujące na zdarzenia

Podstawowa składnia funkcji czyszczącej

W useEffect, funkcja czyszcząca jest zwracana z funkcji efektu:

useEffect(() => {
  // Kod efektu - uruchamiany po renderowaniu
  console.log('Efekt uruchomiony');

  // Funkcja czyszcząca - uruchamiana przed następnym efektem lub przy odmontowaniu
  return () => {
    console.log('Efekt wyczyszczony');
  };
}, [dependency]); // Tablica zależności

Kiedy funkcja czyszcząca jest wywoływana?

Funkcja czyszcząca jest uruchamiana w dwóch sytuacjach:

  1. Przed ponownym uruchomieniem efektu - gdy zmieniają się zależności
  2. Przed odmontowaniem komponentu - gdy komponent jest usuwany z DOM
function SpaceModule({ moduleId }) {
  useEffect(() => {
    console.log(`Moduł ${moduleId} został zainicjalizowany`);

    // Ta funkcja zostanie wywołana:
    // 1. Przed następną inicjalizacją, gdy moduleId się zmieni
    // 2. Gdy komponent SpaceModule zostanie odmontowany
    return () => {
      console.log(`Moduł ${moduleId} został wyłączony`);
    };
  }, [moduleId]);

  return <div className="space-module">Moduł kosmiczny: {moduleId}</div>;
}

Typowe przypadki wymagające czyszczenia

1. Interwały i timeouty

Niezwolnione interwały i timeouty mogą nadal działać w tle, zużywając zasoby i potencjalnie aktualizując stan nieistniejących już komponentów:

function Countdown({ seconds, onComplete }) {
  const [timeLeft, setTimeLeft] = useState(seconds);

  useEffect(() => {
    // Nie rozpoczynaj odliczania, jeśli już zakończone
    if (timeLeft <= 0) {
      onComplete();
      return;
    }

    console.log(`Rozpoczynam odliczanie od ${timeLeft}`);

    // Ustawienie interwału
    const intervalId = setInterval(() => {
      setTimeLeft(prevTime => {
        if (prevTime <= 1) {
          onComplete();
          return 0;
        }
        return prevTime - 1;
      });
    }, 1000);

    // Funkcja czyszcząca zatrzymuje interwał
    return () => {
      console.log(`Zatrzymuję odliczanie na ${timeLeft}`);
      clearInterval(intervalId);
    };
  }, [timeLeft, onComplete]);

  return <div className="countdown">{timeLeft}</div>;
}

2. Subskrypcje do zewnętrznych źródeł danych

Subskrypcje, które nie są anulowane, mogą nadal otrzymywać dane i powodować aktualizacje stanu:

function TelemetryMonitor({ shipId }) {
  const [data, setData] = useState(null);

  useEffect(() => {
    let isMounted = true;
    console.log(`Rozpoczynam monitorowanie statku ${shipId}`);

    // Utworzenie subskrypcji do telemetrii
    const subscription = telemetryService.subscribe(shipId, telemetryData => {
      // Aktualizuj stan tylko jeśli komponent jest nadal zamontowany
      if (isMounted) {
        setData(telemetryData);
      }
    });

    // Funkcja czyszcząca anuluje subskrypcję
    return () => {
      console.log(`Kończę monitorowanie statku ${shipId}`);
      isMounted = false;
      subscription.unsubscribe();
    };
  }, [shipId]);

  if (!data) return <div>Oczekiwanie na dane telemetryczne...</div>;

  return (
    <div className="telemetry">
      <h3>Telemetria statku: {shipId}</h3>
      <p>Poziom tlenu: {data.oxygen}%</p>
      <p>Temperatura: {data.temperature}°C</p>
      <p>Prędkość: {data.velocity} km/h</p>
    </div>
  );
}

3. Nasłuchiwanie zdarzeń DOM

Nasłuchiwacze zdarzeń, które nie są usuwane, mogą prowadzić do wycieków pamięci:

function KeyboardShortcuts({ onEscape }) {
  useEffect(() => {
    console.log('Instaluję nasłuchiwacz klawiatury');

    // Funkcja obsługująca naciśnięcie klawisza
    const handleKeyDown = (event) => {
      if (event.key === 'Escape') {
        onEscape();
      }
    };

    // Dodanie nasłuchiwacza do dokumentu
    document.addEventListener('keydown', handleKeyDown);

    // Funkcja czyszcząca usuwa nasłuchiwacz
    return () => {
      console.log('Usuwam nasłuchiwacz klawiatury');
      document.removeEventListener('keydown', handleKeyDown);
    };
  }, [onEscape]);

  return null; // Ten komponent nie renderuje niczego widocznego
}

4. WebSockets i połączenia czasu rzeczywistego

Połączenia, które pozostają otwarte, mogą zużywać zasoby i powodować wycieki:

function MissionControlSocket({ missionId, onMessage }) {
  const [status, setStatus] = useState('disconnected');

  useEffect(() => {
    let socket = null;

    // Funkcja inicjalizująca połączenie
    const connect = () => {
      console.log(`Łączenie z misją ${missionId}`);
      setStatus('connecting');

      // Utworzenie WebSocketa
      socket = new WebSocket(`wss://mission-control.space/mission/${missionId}`);

      socket.onopen = () => {
        console.log(`Połączono z misją ${missionId}`);
        setStatus('connected');
      };

      socket.onmessage = (event) => {
        const data = JSON.parse(event.data);
        onMessage(data);
      };

      socket.onerror = (error) => {
        console.error(`Błąd połączenia WebSocket: ${error.message}`);
        setStatus('error');
      };

      socket.onclose = () => {
        console.log(`Rozłączono z misją ${missionId}`);
        setStatus('disconnected');
      };
    };

    // Inicjalizacja połączenia
    connect();

    // Funkcja czyszcząca zamyka połączenie
    return () => {
      console.log(`Zamykanie połączenia z misją ${missionId}`);
      if (socket) {
        socket.close();
      }
    };
  }, [missionId, onMessage]);

  return (
    <div className="socket-status">
      Status połączenia: {status}
    </div>
  );
}

5. Anulowanie żądań fetch

Anulowanie trwających żądań fetch zapobiega aktualizacjom stanu po odmontowaniu:

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

  useEffect(() => {
    // Utworzenie kontrolera do anulowania żądania
    const abortController = new AbortController();
    const signal = abortController.signal;

    async function fetchPlanetData() {
      try {
        setLoading(true);

        console.log(`Pobieranie danych planety ${planetId}`);
        const response = await fetch(`https://api.space.com/planets/${planetId}`, {
          signal // przekazanie sygnału do fetch
        });

        if (!response.ok) {
          throw new Error(`HTTP Error: ${response.status}`);
        }

        const data = await response.json();
        setPlanet(data);
        setError(null);
      } catch (err) {
        // Ignoruj błędy anulowania
        if (err.name !== 'AbortError') {
          console.error(`Błąd pobierania danych: ${err.message}`);
          setError(`Nie udało się pobrać danych planety: ${err.message}`);
        }
      } finally {
        setLoading(false);
      }
    }

    fetchPlanetData();

    // Funkcja czyszcząca anuluje trwające żądania
    return () => {
      console.log(`Anulowanie żądania dla planety ${planetId}`);
      abortController.abort();
    };
  }, [planetId]);

  if (loading) return <div>Ładowanie danych planety...</div>;
  if (error) return <div>Błąd: {error}</div>;
  if (!planet) return <div>Brak danych planety</div>;

  return (
    <div className="planet-card">
      <h2>{planet.name}</h2>
      <p>Typ: {planet.type}</p>
      <p>Średnica: {planet.diameter} km</p>
      <p>Odległość od Słońca: {planet.distanceFromSun} mln km</p>
    </div>
  );
}

Zaawansowane wzorce czyszczenia efektów

1. Flaga isMounted

Chociaż użycie AbortController jest preferowanym sposobem anulowania żądań fetch, w przypadkach, gdy nie możemy łatwo anulować operacji asynchronicznej, możemy użyć flagi isMounted:

function AsteroidTracker({ asteroidId }) {
  const [data, setData] = useState(null);

  useEffect(() => {
    let isMounted = true; // Flaga informująca, czy komponent jest zamontowany

    async function fetchAsteroidData() {
      const response = await fetch(`https://api.nasa.gov/neo/rest/v1/neo/${asteroidId}`);
      const asteroidData = await response.json();

      // Aktualizuj stan tylko jeśli komponent jest nadal zamontowany
      if (isMounted) {
        setData(asteroidData);
      }
    }

    fetchAsteroidData();

    // Funkcja czyszcząca zmienia flagę
    return () => {
      isMounted = false;
    };
  }, [asteroidId]);

  // Renderowanie...
}

2. Synchronizacja z zewnętrznymi składowymi stanu

Gdy synchronizujemy stan React z zewnętrznym składowym stanu, ważne jest, aby przywrócić poprzedni stan podczas czyszczenia:

function ThemeSwitcher({ theme }) {
  useEffect(() => {
    // Zapisanie aktualnego motywu
    const previousTheme = document.body.dataset.theme;

    // Ustawienie nowego motywu
    document.body.dataset.theme = theme;
    console.log(`Zmieniam motyw na: ${theme}`);

    // Przywrócenie poprzedniego motywu podczas czyszczenia
    return () => {
      console.log(`Przywracam poprzedni motyw: ${previousTheme || 'default'}`);
      document.body.dataset.theme = previousTheme || 'default';
    };
  }, [theme]);

  return (
    <div className="theme-info">
      Aktualny motyw: {theme}
    </div>
  );
}

3. Obsługa zasobów współdzielonych

Gdy wiele komponentów współdzieli zasoby, należy użyć systemu zliczania referencji:

// Singleton do zarządzania współdzielonymi zasobami
class SharedResourceManager {
  constructor() {
    this.resources = new Map();
    this.refCounts = new Map();
  }

  // Pozyskanie zasobu (zwiększenie licznika referencji)
  acquire(resourceId, creator) {
    if (!this.resources.has(resourceId)) {
      // Tworzenie zasobu, jeśli nie istnieje
      this.resources.set(resourceId, creator());
      this.refCounts.set(resourceId, 0);
    }

    // Zwiększenie licznika referencji
    this.refCounts.set(resourceId, this.refCounts.get(resourceId) + 1);
    return this.resources.get(resourceId);
  }

  // Zwolnienie zasobu (zmniejszenie licznika referencji)
  release(resourceId) {
    if (!this.resources.has(resourceId)) return;

    // Zmniejszenie licznika referencji
    const newCount = this.refCounts.get(resourceId) - 1;
    this.refCounts.set(resourceId, newCount);

    // Usunięcie zasobu, gdy nie ma już referencji
    if (newCount <= 0) {
      const resource = this.resources.get(resourceId);
      if (resource.dispose && typeof resource.dispose === 'function') {
        resource.dispose();
      }
      this.resources.delete(resourceId);
      this.refCounts.delete(resourceId);
    }
  }
}

// Singleton do użycia w całej aplikacji
export const sharedResources = new SharedResourceManager();

// Hook do użycia współdzielonego zasobu
function useSharedResource(resourceId, createResource) {
  useEffect(() => {
    // Pozyskanie zasobu
    const resource = sharedResources.acquire(resourceId, createResource);
    console.log(`Zasób ${resourceId} pozyskany, liczba użytkowników: ${sharedResources.refCounts.get(resourceId)}`);

    // Zwolnienie zasobu przy czyszczeniu
    return () => {
      sharedResources.release(resourceId);
      console.log(`Zasób ${resourceId} zwolniony`);
    };
  }, [resourceId]);

  return sharedResources.resources.get(resourceId);
}

// Przykład użycia
function SpaceshipScanner() {
  // Ten zasób będzie współdzielony między wszystkimi instancjami komponentu
  const scanner = useSharedResource('advanced-scanner', () => {
    console.log('Inicjalizacja skanera (kosztowna operacja)');
    return {
      scan: (target) => console.log(`Skanowanie ${target}...`),
      dispose: () => console.log('Wyłączanie skanera')
    };
  });

  return (
    <button onClick={() => scanner.scan('Mars')}>
      Skanuj Mars
    </button>
  );
}

Typowe problemy i rozwiązania

1. Przepełnienie stosu wywołań przy czyszczeniu timera

Problem: Niepoprawne zatrzymanie timera może prowadzić do przepełnienia stosu:

// ŹLE: Funkcja czyszcząca nie zatrzymuje timeoutu prawidłowo
useEffect(() => {
  function tick() {
    setCount(count + 1);
    setTimeout(tick, 1000);
  }

  tick();

  return () => {
    // Problem: nie mamy odniesienia do aktualnego timeout ID
  };
}, [count]); // Zależność powoduje ponowne uruchomienie efektu

Rozwiązanie: Przechowuj aktualny identyfikator timeout:

// DOBRZE: Zapisujemy ID timeoutu, aby móc go anulować
useEffect(() => {
  let timeoutId = null;

  function tick() {
    setCount(prevCount => prevCount + 1);
    timeoutId = setTimeout(tick, 1000);
  }

  timeoutId = setTimeout(tick, 1000);

  return () => {
    clearTimeout(timeoutId);
  };
}, []); // Brak zależności - uruchamiamy tylko raz

2. Problemy z kolejnością czyszczenia

Problem: Czasami kolejność czyszczenia ma znaczenie, szczególnie gdy mamy kilka zagnieżdżonych efektów:

// Problematyczna kolejność czyszczenia
useEffect(() => {
  // Efekt zewnętrzny
  const resource = initializeResource();

  useEffect(() => {
    // Efekt wewnętrzny korzystający z zasobu
    resource.use();

    return () => {
      // To czyszczenie może być wywołane po zwolnieniu zasobu
      resource.stopUsing();
    };
  }, [someCondition]);

  return () => {
    // Ten zasób może być już używany przez wewnętrzny efekt
    resource.dispose();
  };
}, []);

Rozwiązanie: Używaj oddzielnych, niezależnych efektów:

// Lepsze podejście
useEffect(() => {
  // Efekt inicjalizujący zasób
  const resource = initializeResource();

  return () => {
    // Czyszczenie zasobu
    resource.dispose();
  };
}, []);

useEffect(() => {
  // Efekt korzystający z zasobu (używaj useRef lub kontekstu)
  if (resourceRef.current) {
    resourceRef.current.use();

    return () => {
      if (resourceRef.current) {
        resourceRef.current.stopUsing();
      }
    };
  }
}, [someCondition]);

3. Niespójność stanu podczas czyszczenia

Problem: Podczas czyszczenia możemy uzyskać dostęp do nieaktualnego stanu:

function SpaceshipControl({ shipId }) {
  const [power, setPower] = useState(100);

  useEffect(() => {
    // Inicjalizacja kontroli statku
    const ship = spaceshipAPI.connect(shipId);
    ship.setPower(power);

    return () => {
      // Problem: power może być nieaktualne podczas czyszczenia
      console.log(`Odłączanie od statku przy mocy: ${power}`);
      ship.disconnect();
    };
  }, [shipId]); // Brak zależności od power

  return (
    <div>
      <p>Moc silników: {power}%</p>
      <button onClick={() => setPower(power - 10)}>Zmniejsz moc</button>
    </div>
  );
}

Rozwiązanie: Używaj referencji do przechowywania aktualnych wartości stanu:

function SpaceshipControl({ shipId }) {
  const [power, setPower] = useState(100);
  const powerRef = useRef(power);

  // Aktualizacja referencji przy każdej zmianie stanu
  useEffect(() => {
    powerRef.current = power;
  }, [power]);

  useEffect(() => {
    // Inicjalizacja kontroli statku
    const ship = spaceshipAPI.connect(shipId);
    ship.setPower(power);

    return () => {
      // Używamy aktualnej wartości z referencji
      console.log(`Odłączanie od statku przy mocy: ${powerRef.current}%`);
      ship.disconnect();
    };
  }, [shipId, power]);

  return (
    <div>
      <p>Moc silników: {power}%</p>
      <button onClick={() => setPower(power - 10)}>Zmniejsz moc</button>
    </div>
  );
}

Testowanie czyszczenia efektów

Aby upewnić się, że efekty są poprawnie czyszczone, warto pisać testy sprawdzające to zachowanie:

// Przykład testu dla komponentu z czyszczeniem efektu
import { render, act, screen } from '@testing-library/react';
import { useState } from 'react';

// Prosty komponent z timerem do testowania
function TimerComponent() {
  const [count, setCount] = useState(0);

  useEffect(() => {
    const interval = setInterval(() => {
      setCount(c => c + 1);
    }, 100);

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

  return <div data-testid="count">{count}</div>;
}

// Test czyszczenia efektu
test('effect cleanup stops the interval', async () => {
  jest.useFakeTimers();

  const { unmount } = render(<TimerComponent />);

  // Pozwól na kilka tyknięć timera
  act(() => {
    jest.advanceTimersByTime(250);
  });

  const countBefore = Number(screen.getByTestId('count').textContent);

  // Odmontuj komponent (powinno to wyczyścić efekt i zatrzymać timer)
  unmount();

  // Przesuń zegar do przodu jeszcze raz
  act(() => {
    jest.advanceTimersByTime(250);
  });

  // Ponieważ komponent jest odmontowany i timer zatrzymany,
  // możemy tylko sprawdzić, czy licznik nie wzrósł za bardzo przed odmontowaniem
  expect(countBefore).toBeGreaterThanOrEqual(2);
  expect(countBefore).toBeLessThanOrEqual(3);

  jest.useRealTimers();
});

Najlepsze praktyki czyszczenia efektów

  1. Zawsze czyść efekty, które tworzą subskrypcje - timery, nasłuchiwacze zdarzeń, połączenia WebSocket, itp.

  2. Używaj AbortController do anulowania żądań fetch - jest to standardowy mechanizm do anulowania operacji asynchronicznych.

  3. Utrzymuj flagę montowania - dla operacji asynchronicznych, których nie można anulować, używaj flagi isMounted i sprawdzaj ją przed aktualizacją stanu.

  4. Przechowuj referencje do zasobów - zmienne lokalne w efekcie przestają istnieć po jego wyczyszczeniu, więc używaj useRef do przechowywania odniesień do zasobów.

  5. Unikaj zbyt skomplikowanych efektów - efekt, który robi zbyt wiele rzeczy, będzie trudniejszy do poprawnego wyczyszczenia. Rozważ podzielenie go na mniejsze, bardziej skoncentrowane efekty.

  6. Unikaj asynchronicznych funkcji czyszczących - funkcje czyszczące powinny być synchroniczne, aby React mógł zagwarantować ich wykonanie we właściwej kolejności.

  7. Testuj czyszczenie efektów - szczególnie ważne jest testowanie odmontowywania komponentów, które tworzą zewnętrzne subskrypcje.

Czyszczenie efektów a wydajność

Odpowiednie czyszczenie efektów nie tylko zapobiega wyciekom pamięci, ale może również znacząco wpłynąć na wydajność aplikacji:

  1. Mniejsze zużycie pamięci - przez zwalnianie nieużywanych zasobów

  2. Mniej niepotrzebnych obliczeń - przez anulowanie operacji, które nie są już potrzebne

  3. Redukcja liczby ponownych renderowań - przez unikanie niepotrzebnych aktualizacji stanu

  4. Szybsze przeładowania strony - przez zapewnienie, że wszystkie zasoby są prawidłowo zwalniane

Podsumowanie

Czyszczenie efektów jest często pomijanym, ale kluczowym aspektem pracy z React. Podobnie jak astronauci muszą dbać o swoje systemy podtrzymywania życia, tak programiści muszą dbać o czystość swoich efektów ubocznych.

Dobrze napisane funkcje czyszczące:

  • Zapobiegają wyciekom pamięci
  • Unikają aktualizacji stanu odmontowanych komponentów
  • Zwalniają zasoby systemowe
  • Zapewniają spójność aplikacji

Pamiętaj, że każdy efekt, który tworzy połączenie, subskrypcję lub rezerwuje zasoby, powinien je również zwolnić podczas czyszczenia.

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

// Demonstracja cleanup przy timerach
function TimerWithCleanup() {
  const [count, setCount] = useState(0);
  const [isRunning, setIsRunning] = useState(false);

  useEffect(() => {
    if (!isRunning) return;

    console.log('⏰ Timer started');
    const interval = setInterval(() => {
      setCount(c => c + 1);
    }, 1000);

    // CLEANUP - bardzo ważne!
    return () => {
      console.log('Timer stopped (cleanup)');
      clearInterval(interval);
    };
  }, [isRunning]);

  return (
    <div className="demo-card">
      <h2>⏱Timer z Cleanup</h2>
      <div className="counter">{count}s</div>
      <div className="controls">
        <button onClick={() => setIsRunning(true)} disabled={isRunning}>
          ▶Start
        </button>
        <button onClick={() => setIsRunning(false)} disabled={!isRunning}>
          ⏹Stop
        </button>
        <button onClick={() => { setCount(0); setIsRunning(false); }}>
          Reset
        </button>
      </div>
      <p className="hint">Otwórz konsolę, aby zobaczyć logi cleanup</p>
    </div>
  );
}

// Demonstracja cleanup przy event listenerach
function MouseTrackerWithCleanup() {
  const [position, setPosition] = useState({ x: 0, y: 0 });
  const [tracking, setTracking] = useState(false);

  useEffect(() => {
    if (!tracking) return;

    const handleMouseMove = (e) => {
      setPosition({ x: e.clientX, y: e.clientY });
    };

    console.log('Mouse tracking enabled');
    window.addEventListener('mousemove', handleMouseMove);

    // CLEANUP - usunięcie event listenera
    return () => {
      console.log('Mouse tracking disabled (cleanup)');
      window.removeEventListener('mousemove', handleMouseMove);
    };
  }, [tracking]);

  return (
    <div className="demo-card">
      <h2>Śledzenie Myszy</h2>
      <div className="position">
        X: {position.x} | Y: {position.y}
      </div>
      <button onClick={() => setTracking(!tracking)}>
        {tracking ? 'Wyłącz śledzenie' : 'Włącz śledzenie'}
      </button>
      <p className="hint">
        {tracking ? 'Poruszaj myszą!' : 'Kliknij, aby włączyć'}
      </p>
    </div>
  );
}

// Demonstracja cleanup przy subskrypcjach
function SubscriptionWithCleanup() {
  const [messages, setMessages] = useState([]);
  const [subscribed, setSubscribed] = useState(false);

  useEffect(() => {
    if (!subscribed) return;

    console.log('Subscribed to space channel');

    // Symulacja subskrypcji (np. WebSocket)
    const interval = setInterval(() => {
      const newMessage = {
        id: Date.now(),
        text: `Transmisja #${Math.floor(Math.random() * 1000)}`,
        time: new Date().toLocaleTimeString()
      };
      setMessages(prev => [...prev.slice(-4), newMessage]);
    }, 2000);

    // CLEANUP - anulowanie subskrypcji
    return () => {
      console.log('Unsubscribed from space channel (cleanup)');
      clearInterval(interval);
    };
  }, [subscribed]);

  return (
    <div className="demo-card">
      <h2>Subskrypcja</h2>
      <div className="messages">
        {messages.length === 0 ? (
          <p className="empty">Brak wiadomości</p>
        ) : (
          messages.map(msg => (
            <div key={msg.id} className="message">
              [{msg.time}] {msg.text}
            </div>
          ))
        )}
      </div>
      <button onClick={() => {
        setSubscribed(!subscribed);
        if (subscribed) setMessages([]);
      }}>
        {subscribed ? 'Anuluj subskrypcję' : 'Subskrybuj'}
      </button>
    </div>
  );
}

// Komponent pokazujący problem z wyciekiem pamięci
function MemoryLeakDemo() {
  const [showChild, setShowChild] = useState(true);
  const [logs, setLogs] = useState([]);

  const addLog = (msg) => setLogs(prev => [...prev.slice(-5), msg]);

  return (
    <div className="demo-card wide">
      <h2>Demo Wycieków Pamięci</h2>
      <button onClick={() => {
        setShowChild(!showChild);
        addLog(showChild ? 'Komponent odmontowany' : 'Komponent zamontowany');
      }}>
        {showChild ? 'Odmontuj komponent' : 'Zamontuj komponent'}
      </button>

      <div className="child-container">
        {showChild && <ChildWithCleanup onLog={addLog} />}
      </div>

      <div className="logs">
        <h3>Logi:</h3>
        {logs.map((log, i) => <div key={i}>{log}</div>)}
      </div>
    </div>
  );
}

function ChildWithCleanup({ onLog }) {
  useEffect(() => {
    onLog('Effect uruchomiony');

    const timer = setInterval(() => {
      onLog('⏰ Timer tick');
    }, 2000);

    return () => {
      onLog('Cleanup wykonany - timer wyczyszczony');
      clearInterval(timer);
    };
  }, []);

  return <div className="child">Komponent potomny (z efektem)</div>;
}

function App() {
  return (
    <div className="app">
      <h1>Czyszczenie Efektów (Cleanup)</h1>
      <p className="subtitle">Zarządzanie zasobami w useEffect</p>
      <div className="demos">
        <TimerWithCleanup />
        <MouseTrackerWithCleanup />
        <SubscriptionWithCleanup />
        <MemoryLeakDemo />
      </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. Jak najlepiej organizować wiele efektów w komponencie?

  2. 2. Jak poprawnie obsługiwać błędy w asynchronicznych operacjach w useEffect?

Zadania praktyczne w grze

  • Układanie w poziomie

    Ułóż elementy składni cleanup w useEffect od lewej do prawej:

  • Edytor kodu

    LocalStorage settings sync

  • Klikanie w kolejności

    Ułóż składnię useEffect z funkcją cleanup:

  • Układanie w pionie

    Uporządkuj zaawansowane wzorce useEffect od podstawowych do skomplikowanych:

  • Edytor kodu

    Intersection Observer do lazy loading

  1. PytanieWiele efektów
  2. Ułóż w kolejnościFunkcja cleanup w useEffect
  3. PytanieObsługa błędów w efektach
  4. Zadanie z kodemPraktyka: localStorage sync
  5. Kliknij w kolejnościFunkcja cleanup w useEffect
  6. Ułóż w kolejnościZaawansowane wzorce efektów
  7. Zadanie z kodemPraktyka: Intersection Observer

Przydatne artykuły