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

Synchronizacja z zewnętrznymi systemami

11 min czytania ·
W tej lekcji7

W poprzednim module poznaliśmy podstawy efektów ubocznych z hookiem useEffect. Teraz zagłębimy się w jeden z najważniejszych przypadków użycia efektów: synchronizację komponentów React z zewnętrznymi systemami i bibliotekami.

Dlaczego synchronizacja jest ważna?

Komponenty React istnieją w swoim reaktywnym środowisku, ale często muszą współpracować z niezależnymi systemami, które nie są świadome cyklu życia React ani jego modelu renderowania. Możesz wyobrazić sobie to jako mostek między statkiem kosmicznym React a innymi systemami - komunikacja musi być dwustronna i niezawodna.

Przykładami takich zewnętrznych systemów są:

  • Biblioteki map (np. Google Maps, Leaflet)
  • Biblioteki wykresów (np. D3.js, Chart.js)
  • Odtwarzacze mediów (np. HTML5 Video, Web Audio API)
  • SDK do websocketów i komunikacji czasu rzeczywistego
  • Systemy zarządzania formularzami (np. Formik, React Hook Form)
  • Biblioteki animacji (np. GSAP, Anime.js)
  • Interfejsy przeglądarki (geolokalizacja, Web Bluetooth)

Podstawowy wzorzec synchronizacji

Podstawowy wzorzec synchronizacji z zewnętrznym systemem wygląda następująco:

  1. Inicjalizuj zewnętrzną bibliotekę/system po pierwszym renderowaniu
  2. Aktualizuj zewnętrzny system, gdy zmieniają się odpowiednie props lub stan
  3. Sprzątaj po sobie (zatrzymaj, odłącz), gdy komponent jest odmontowywany
function ExternalSystemComponent({ config }) {
  useEffect(() => {
    // 1. Inicjalizacja
    const externalInstance = new ExternalSystem(config);
    externalInstance.initialize();

    // 2. Aktualizacja (opcjonalnie)
    externalInstance.update(config);

    // 3. Sprzątanie
    return () => {
      externalInstance.cleanup();
    };
  }, [config]); // Ponowna synchronizacja, gdy zmienia się konfiguracja

  return <div className="external-system-container" />;
}

Praktyczne przykłady synchronizacji

1. Integracja z biblioteką map (Leaflet)

Leaflet to popularna biblioteka do interaktywnych map, która działa niezależnie od React. Oto przykład integracji:

import React, { useEffect, useRef } from 'react';
import L from 'leaflet';
import 'leaflet/dist/leaflet.css';

function MarsExplorationMap({ missionCoordinates, roverPosition, zoom = 5 }) {
  // Ref do kontenera mapy
  const mapContainerRef = useRef(null);
  // Ref do instancji mapy (aby uniknąć ponownego tworzenia)
  const mapInstanceRef = useRef(null);
  // Ref do markera łazika (aby aktualizować tylko jego pozycję)
  const roverMarkerRef = useRef(null);

  // Inicjalizacja mapy
  useEffect(() => {
    if (!mapInstanceRef.current && mapContainerRef.current) {
      // Tworzenie instancji mapy tylko raz
      const mapInstance = L.map(mapContainerRef.current).setView(
        [missionCoordinates.lat, missionCoordinates.lng],
        zoom
      );

      // Dodanie warstwy mapy
      L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png', {
        attribution: '© OpenStreetMap contributors'
      }).addTo(mapInstance);

      // Zapisanie instancji mapy w referencji
      mapInstanceRef.current = mapInstance;

      // Dodanie markera łazika
      roverMarkerRef.current = L.marker([roverPosition.lat, roverPosition.lng])
        .addTo(mapInstance)
        .bindPopup('Łazik marsjański');
    }

    // Funkcja czyszcząca
    return () => {
      if (mapInstanceRef.current) {
        // Usunięcie mapy przy odmontowaniu komponentu
        mapInstanceRef.current.remove();
        mapInstanceRef.current = null;
        roverMarkerRef.current = null;
      }
    };
  }, []); // Pusta tablica zależności - inicjalizacja tylko raz

  // Aktualizacja pozycji łazika
  useEffect(() => {
    if (roverMarkerRef.current && roverPosition) {
      // Aktualizacja pozycji istniejącego markera
      roverMarkerRef.current.setLatLng([roverPosition.lat, roverPosition.lng]);
    }
  }, [roverPosition]); // Aktualizuj tylko gdy zmienia się pozycja łazika

  // Aktualizacja poziomu przybliżenia
  useEffect(() => {
    if (mapInstanceRef.current) {
      mapInstanceRef.current.setZoom(zoom);
    }
  }, [zoom]); // Aktualizuj tylko gdy zmienia się zoom

  return <div ref={mapContainerRef} style={{ height: '500px', width: '100%' }} />;
}

W powyższym przykładzie:

  1. Używamy referencji (useRef) do przechowywania elementów DOM i instancji biblioteki zewnętrznej
  2. Inicjalizujemy mapę tylko raz i zapisujemy jej instancję
  3. Używamy oddzielnych efektów do obsługi różnych aspektów synchronizacji
  4. Czyścimy zasoby, gdy komponent jest odmontowywany

2. Integracja z biblioteką wykresów (Chart.js)

Chart.js to popularna biblioteka do tworzenia interaktywnych wykresów:

import React, { useEffect, useRef } from 'react';
import Chart from 'chart.js/auto';

function MissionResourcesChart({ resources, title }) {
  const chartRef = useRef(null);
  const chartInstanceRef = useRef(null);

  useEffect(() => {
    // Upewniamy się, że mamy dostęp do elementu canvas
    if (!chartRef.current) return;

    // Pobierz kontekst canvas
    const ctx = chartRef.current.getContext('2d');

    // Zniszcz poprzednią instancję wykresu, jeśli istnieje
    if (chartInstanceRef.current) {
      chartInstanceRef.current.destroy();
    }

    // Utwórz nową instancję wykresu
    chartInstanceRef.current = new Chart(ctx, {
      type: 'bar',
      data: {
        labels: resources.map(resource => resource.name),
        datasets: [{
          label: title || 'Zasoby misji',
          data: resources.map(resource => resource.level),
          backgroundColor: resources.map(resource => {
            // Kolorowanie słupków w zależności od poziomu zasobów
            if (resource.level < 20) return 'rgba(255, 0, 0, 0.7)'; // Krytyczny
            if (resource.level < 50) return 'rgba(255, 165, 0, 0.7)'; // Ostrzeżenie
            return 'rgba(0, 128, 0, 0.7)'; // OK
          }),
          borderColor: 'rgba(0, 0, 0, 0.1)',
          borderWidth: 1
        }]
      },
      options: {
        responsive: true,
        scales: {
          y: {
            beginAtZero: true,
            max: 100
          }
        }
      }
    });

    // Sprzątanie
    return () => {
      if (chartInstanceRef.current) {
        chartInstanceRef.current.destroy();
        chartInstanceRef.current = null;
      }
    };
  }, [resources, title]); // Ponowne tworzenie wykresu przy zmianie danych lub tytułu

  return <canvas ref={chartRef} />;
}

3. Obsługa Web Sockets

Integracja z Web Sockets umożliwia komunikację czasu rzeczywistego:

import React, { useEffect, useState } from 'react';

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

  useEffect(() => {
    // Inicjalizacja socketu
    const socket = new WebSocket(`wss://mission-control.example.com/ws/${missionId}`);

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

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

    socket.onerror = (err) => {
      setStatus('error');
      setError('Błąd połączenia z centrum kontroli misji');
      console.error('WebSocket error:', err);
    };

    socket.onclose = () => {
      setStatus('disconnected');
      console.log('Połączenie zamknięte');
    };

    // Funkcja czyszcząca
    return () => {
      // Zamknięcie połączenia przy odmontowaniu
      if (socket.readyState === WebSocket.OPEN) {
        socket.close();
      }
    };
  }, [missionId, onMessage]); // Ponowne połączenie przy zmianie missionId

  return (
    <div className="mission-socket">
      <div className={`connection-status ${status}`}>
        Status połączenia: {status}
      </div>
      {error && <div className="connection-error">{error}</div>}
    </div>
  );
}

Strategie efektywnej synchronizacji

1. Minimalizacja ponownych inicjalizacji

Unikaj niepotrzebnego inicjalizowania zewnętrznych systemów, gdy tylko część konfiguracji się zmienia. Zamiast tego:

  1. Używaj osobnych efektów dla różnych aspektów synchronizacji
  2. Wykorzystuj referencje do przechowywania instancji zewnętrznych bibliotek
  3. Aktualizuj istniejące instancje zamiast tworzyć nowe
// ŹLE - pojedynczy efekt reinikcjalizuje całość
useEffect(() => {
  const chart = new ChartLibrary(config);
  return () => chart.destroy();
}, [config]); // Każda zmiana w config spowoduje reinicjalizację

// DOBRZE - oddzielna inicjalizacja i aktualizacja
// Ref do przechowywania instancji
const chartRef = useRef(null);

// Inicjalizacja tylko raz
useEffect(() => {
  chartRef.current = new ChartLibrary(containerRef.current);
  return () => chartRef.current.destroy();
}, []);

// Aktualizacja konfiguracji bez reinicjalizacji
useEffect(() => {
  if (chartRef.current) {
    chartRef.current.updateConfig(config);
  }
}, [config]);

2. Zarządzanie subskrypcjami

Przy pracy z zewnętrznymi źródłami danych, które używają subskrypcji:

  1. Zawsze anuluj subskrypcje w funkcji czyszczącej
  2. Aktualizuj subskrypcje, gdy zmieniają się parametry
function TelemetryMonitor({ satelliteId, dataType }) {
  const [data, setData] = useState(null);

  useEffect(() => {
    // Utworzenie subskrypcji
    const subscription = telemetryAPI.subscribe(
      satelliteId,
      dataType,
      (newData) => setData(newData)
    );

    // Czyszczenie
    return () => subscription.unsubscribe();
  }, [satelliteId, dataType]); // Ponowna subskrypcja gdy zmieni się ID lub typ danych

  return <div>{/* Renderowanie danych */}</div>;
}

3. Opóźnione inicjalizowanie zasobożernych bibliotek

Dla ciężkich bibliotek zewnętrznych, możesz opóźnić ich inicjalizację do momentu, gdy są faktycznie potrzebne:

function HeavyChart({ data, shouldRender }) {
  const [chartInstance, setChartInstance] = useState(null);
  const containerRef = useRef(null);

  // Leniwa inicjalizacja
  useEffect(() => {
    if (!shouldRender) {
      // Nie inicjalizuj jeśli nie powinniśmy jeszcze renderować
      return;
    }

    // Dynamiczny import ciężkiej biblioteki
    import('heavy-chart-library').then(ChartLib => {
      const instance = new ChartLib.Chart(containerRef.current, data);
      setChartInstance(instance);

      return () => {
        instance.destroy();
      };
    });
  }, [shouldRender]); // Uruchom tylko gdy shouldRender zmienia się na true

  // Aktualizacja danych
  useEffect(() => {
    if (chartInstance && data) {
      chartInstance.updateData(data);
    }
  }, [chartInstance, data]);

  return <div ref={containerRef} />;
}

Tworzenie własnych hooków do synchronizacji

Aby poprawić ponowne użycie kodu i enkapsulację logiki synchronizacji, warto tworzyć własne hooki.

Przykład: Custom hook do integracji z mapą

function useLeafletMap(containerRef, initialConfig) {
  const mapRef = useRef(null);
  const [isReady, setIsReady] = useState(false);

  // Inicjalizacja
  useEffect(() => {
    if (!containerRef.current || mapRef.current) return;

    const map = L.map(containerRef.current, initialConfig);
    L.tileLayer('https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png').addTo(map);

    mapRef.current = map;
    setIsReady(true);

    return () => {
      map.remove();
      mapRef.current = null;
      setIsReady(false);
    };
  }, [containerRef, initialConfig]);

  // Metody do manipulacji mapą
  const setView = useCallback((center, zoom) => {
    if (mapRef.current) {
      mapRef.current.setView(center, zoom);
    }
  }, []);

  const addMarker = useCallback((position, options = {}) => {
    if (!mapRef.current) return null;

    const marker = L.marker(position, options).addTo(mapRef.current);
    return marker;
  }, []);

  return {
    map: mapRef.current,
    isReady,
    setView,
    addMarker
  };
}

// Użycie custom hooka
function MarsMap() {
  const containerRef = useRef(null);
  const { map, isReady, setView, addMarker } = useLeafletMap(
    containerRef,
    { center: [24.7136, 46.6753], zoom: 5 }
  );

  // Dodanie markera po załadowaniu mapy
  useEffect(() => {
    if (isReady) {
      const marker = addMarker([24.7136, 46.6753], { title: 'Baza Alfa' });
      marker.bindPopup('Baza Alfa - Główna kolonia na Marsie').openPopup();
    }
  }, [isReady, addMarker]);

  return (
    <div>
      <h2>Mapa kolonii marsjańskiej</h2>
      <div ref={containerRef} style={{ height: '500px' }} />
      {!isReady && <div>Ładowanie mapy...</div>}
    </div>
  );
}

Przykład: Custom hook do lokalnego składowania

function useLocalStorage(key, initialValue) {
  // Funkcja inicjalizująca stan - uruchamiana tylko raz
  const [storedValue, setStoredValue] = useState(() => {
    try {
      // Sprawdzenie czy localStorage jest dostępny
      if (typeof window === 'undefined') {
        return initialValue;
      }

      // Próba pobrania wartości z localStorage
      const item = window.localStorage.getItem(key);
      return item ? JSON.parse(item) : initialValue;
    } catch (error) {
      console.error('Błąd odczytu z localStorage:', error);
      return initialValue;
    }
  });

  // Funkcja aktualizująca wartość w localStorage
  const setValue = useCallback((value) => {
    try {
      // Obsługa funkcji jako wartości (jak w setState)
      const valueToStore = value instanceof Function ? value(storedValue) : value;

      // Aktualizacja stanu React
      setStoredValue(valueToStore);

      // Aktualizacja localStorage
      if (typeof window !== 'undefined') {
        window.localStorage.setItem(key, JSON.stringify(valueToStore));
      }
    } catch (error) {
      console.error('Błąd zapisu do localStorage:', error);
    }
  }, [key, storedValue]);

  // Synchronizacja z localStorage przy zmianie klucza
  useEffect(() => {
    // Pobranie aktualnej wartości dla nowego klucza
    try {
      if (typeof window === 'undefined') return;

      const item = window.localStorage.getItem(key);
      setStoredValue(item ? JSON.parse(item) : initialValue);
    } catch (error) {
      console.error('Błąd synchronizacji z localStorage:', error);
    }
  }, [key, initialValue]);

  return [storedValue, setValue];
}

// Użycie custom hooka
function AstronautSettings() {
  const [settings, setSettings] = useLocalStorage('astronaut-settings', {
    oxygenAlert: 20,
    darkMode: false,
    notifications: true
  });

  const toggleDarkMode = () => {
    setSettings(prev => ({
      ...prev,
      darkMode: !prev.darkMode
    }));
  };

  return (
    <div className={settings.darkMode ? 'dark-theme' : 'light-theme'}>
      <h2>Ustawienia astronauty</h2>
      <button onClick={toggleDarkMode}>
        Przełącz na tryb {settings.darkMode ? 'jasny' : 'ciemny'}
      </button>
      <div>
        Powiadomienie o poziomie tlenu: {settings.oxygenAlert}%
        <input
          type="range"
          min="5"
          max="50"
          value={settings.oxygenAlert}
          onChange={e => setSettings({
            ...settings,
            oxygenAlert: Number(e.target.value)
          })}
        />
      </div>
      <label>
        <input
          type="checkbox"
          checked={settings.notifications}
          onChange={() => setSettings(prev => ({
            ...prev,
            notifications: !prev.notifications
          }))}
        />
        Włącz powiadomienia
      </label>
    </div>
  );
}

Obsługa efektów w testach

Testowanie komponentów, które synchronizują się z zewnętrznymi systemami, wymaga specjalnego podejścia:

  1. Mockowanie zewnętrznych bibliotek
  2. Testowanie efektów czyszczących
  3. Sprawdzanie, czy synchronizacja działa poprawnie

Przykład testu dla komponentu z WebSocket:

import { render, act, screen, waitFor } from '@testing-library/react';
import MissionControlSocket from './MissionControlSocket';

// Mock dla WebSocket
class MockWebSocket {
  constructor(url) {
    this.url = url;
    this.readyState = WebSocket.CONNECTING;

    // Automatyczne "połączenie" po utworzeniu
    setTimeout(() => {
      this.readyState = WebSocket.OPEN;
      this.onopen && this.onopen();
    }, 0);
  }

  // Metody do symulowania zdarzeń z zewnątrz
  simulateMessage(data) {
    this.onmessage && this.onmessage({ data: JSON.stringify(data) });
  }

  simulateError() {
    this.onerror && this.onerror(new Error('Test error'));
  }

  simulateClose() {
    this.readyState = WebSocket.CLOSED;
    this.onclose && this.onclose();
  }

  close() {
    this.simulateClose();
  }
}

// Podmiana globalnej klasy WebSocket
global.WebSocket = MockWebSocket;

describe('MissionControlSocket', () => {
  test('should connect to WebSocket and handle messages', async () => {
    const mockOnMessage = jest.fn();

    render(
      <MissionControlSocket
        missionId="apollo11"
        onMessage={mockOnMessage}
      />
    );

    // Czekaj na połączenie
    await waitFor(() => {
      expect(screen.getByText(/status połączenia: connected/i)).toBeInTheDocument();
    });

    // Symulacja otrzymania wiadomości
    const testData = { type: 'telemetry', oxygen: 95, fuel: 76 };
    act(() => {
      // Dostęp do instancji WebSocket przez monkeypatching
      const socket = global.WebSocket.instances[0];
      socket.simulateMessage(testData);
    });

    // Sprawdzenie czy callback został wywołany z odpowiednimi danymi
    expect(mockOnMessage).toHaveBeenCalledWith(testData);

    // Symulacja błędu
    act(() => {
      const socket = global.WebSocket.instances[0];
      socket.simulateError();
    });

    // Sprawdzenie czy status błędu jest widoczny
    expect(screen.getByText(/status połączenia: error/i)).toBeInTheDocument();
    expect(screen.getByText(/błąd połączenia/i)).toBeInTheDocument();
  });

  test('should clean up WebSocket connection on unmount', () => {
    const { unmount } = render(
      <MissionControlSocket missionId="apollo11" onMessage={() => {}} />
    );

    // Pobierz instancję WebSocket
    const socket = global.WebSocket.instances[0];
    const closeSpy = jest.spyOn(socket, 'close');

    // Odmontowanie komponentu
    unmount();

    // Sprawdzenie czy socket został zamknięty
    expect(closeSpy).toHaveBeenCalled();
  });
});

Podsumowanie

Synchronizacja z zewnętrznymi systemami to jedna z najważniejszych funkcji hooka useEffect. Umożliwia wykorzystanie istniejących bibliotek i API w ekosystemie React, zachowując reaktywny model aktualizacji.

Najważniejsze zasady:

  1. Inicjalizuj zewnętrzne systemy po pierwszym renderowaniu
  2. Aktualizuj je, gdy zmieniają się odpowiednie dane
  3. Sprzątaj zasoby, gdy komponent jest odmontowywany
  4. Dziel efekty według ich odpowiedzialności
  5. Enkapsuluj logikę synchronizacji w dedykowanych hookach
  6. Minimalizuj zbędne reinicjalizacje
  7. Testuj poprawność synchronizacji i czyszczenia

Pamiętaj, że głównym celem synchronizacji jest utrzymanie spójności między reaktywnym światem React a zewnętrznymi systemami, które nie wiedzą nic o cyklu życia komponentów. Dzięki prawidłowej synchronizacji, Twoja aplikacja będzie działać płynnie i efektywnie, łącząc różne technologie w jedną, spójną całość.

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

// Synchronizacja z zewnętrznym API - system nawigacji kosmicznej
function SpaceNavigationSystem() {
  const [position, setPosition] = useState({ x: 0, y: 0 });
  const [isTracking, setIsTracking] = useState(true);
  const [lastSync, setLastSync] = useState(null);

  // Synchronizacja z "zewnętrznym" systemem nawigacji
  useEffect(() => {
    if (!isTracking) return;

    // Symulacja zewnętrznego systemu nawigacji
    const interval = setInterval(() => {
      setPosition(prev => ({
        x: prev.x + (Math.random() - 0.5) * 10,
        y: prev.y + (Math.random() - 0.5) * 10
      }));
      setLastSync(new Date().toLocaleTimeString());
    }, 1000);

    // Cleanup - rozłączenie z systemem
    return () => {
      console.log('Disconnecting from navigation system...');
      clearInterval(interval);
    };
  }, [isTracking]);

  return (
    <div className="nav-system">
      <h2>System Nawigacji Kosmicznej</h2>
      <div className="status">
        Status: {isTracking ? 'Aktywny' : 'Nieaktywny'}
      </div>
      <div className="coordinates">
        <p>Współrzędne X: {position.x.toFixed(2)}</p>
        <p>Współrzędne Y: {position.y.toFixed(2)}</p>
      </div>
      {lastSync && <p className="sync-time">Ostatnia synchronizacja: {lastSync}</p>}
      <button onClick={() => setIsTracking(!isTracking)}>
        {isTracking ? 'Zatrzymaj śledzenie' : 'Wznów śledzenie'}
      </button>
    </div>
  );
}

// Synchronizacja z DOM - zewnętrzna biblioteka wykresów
function ExternalChartSync() {
  const chartRef = useRef(null);
  const [data, setData] = useState([30, 50, 40, 60, 45, 70, 55]);

  // Synchronizacja z "zewnętrzną biblioteką wykresów"
  useEffect(() => {
    const canvas = chartRef.current;
    if (!canvas) return;

    const ctx = canvas.getContext('2d');
    const width = canvas.width;
    const height = canvas.height;

    // Czyszczenie canvas
    ctx.clearRect(0, 0, width, height);

    // Rysowanie wykresu
    ctx.fillStyle = 'rgba(97, 218, 251, 0.3)';
    ctx.strokeStyle = '#61dafb';
    ctx.lineWidth = 2;

    const barWidth = width / data.length - 10;
    data.forEach((value, index) => {
      const x = index * (barWidth + 10) + 5;
      const barHeight = (value / 100) * height;
      const y = height - barHeight;

      ctx.fillRect(x, y, barWidth, barHeight);
      ctx.strokeRect(x, y, barWidth, barHeight);
    });

    // Cleanup - czyszczenie canvas przy odmontowaniu
    return () => {
      ctx.clearRect(0, 0, width, height);
    };
  }, [data]);

  const updateData = () => {
    setData(prev => prev.map(() => Math.random() * 100));
  };

  return (
    <div className="chart-sync">
      <h2>Synchronizacja z Canvas</h2>
      <canvas ref={chartRef} width={350} height={200} />
      <button onClick={updateData}>Odśwież dane</button>
    </div>
  );
}

// Synchronizacja z WebSocket (symulacja)
function WebSocketSync() {
  const [messages, setMessages] = useState([]);
  const [connected, setConnected] = useState(false);

  useEffect(() => {
    // Symulacja połączenia WebSocket
    console.log('Connecting to WebSocket...');
    setConnected(true);

    const interval = setInterval(() => {
      const newMessage = {
        id: Date.now(),
        text: `Wiadomość z kosmosu #${Math.floor(Math.random() * 1000)}`,
        time: new Date().toLocaleTimeString()
      };
      setMessages(prev => [...prev.slice(-4), newMessage]);
    }, 2000);

    // Cleanup - zamknięcie połączenia
    return () => {
      console.log('Closing WebSocket connection...');
      clearInterval(interval);
      setConnected(false);
    };
  }, []);

  return (
    <div className="websocket-sync">
      <h2>Komunikacja WebSocket</h2>
      <div className="connection-status">
        {connected ? 'Połączono' : 'Rozłączono'}
      </div>
      <div className="messages">
        {messages.map(msg => (
          <div key={msg.id} className="message">
            <span className="time">[{msg.time}]</span> {msg.text}
          </div>
        ))}
      </div>
    </div>
  );
}

function App() {
  return (
    <div className="app">
      <h1>Synchronizacja z zewnętrznymi systemami</h1>
      <div className="demos">
        <SpaceNavigationSystem />
        <ExternalChartSync />
        <WebSocketSync />
      </div>
    </div>
  );
}

export default App;

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Układanie w pionie

    Uporządkuj warianty useEffect od najczęściej do najrzadziej uruchamianego:

  • Edytor kodu

    Stwórz [seconds, setSeconds] = useState(0). useEffect z setInterval co 1s: setSeconds(s => s + 1). WAŻNE: return () => clearInterval(intervalId) - cleanup zapobiega wyciekom pamięci! Wyświetl: 'Czas misji: {seconds}s'

  • Układanie w pionie

    Uporządkuj etapy cyklu życia efektu z funkcją cleanup:

  • Klikanie w kolejności

    Uporządkuj strukturę komponentu z useEffect:

  1. Ułóż w kolejnościDependency array
  2. Zadanie z kodemPraktyka: Timer z useEffect
  3. Ułóż w kolejnościCykl życia funkcji cleanup w useEffect
  4. Kliknij w kolejnościStruktura podstawowego efektu

Przydatne artykuły