Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Synchronizacja z zewnętrznymi systemami
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:
- Inicjalizuj zewnętrzną bibliotekę/system po pierwszym renderowaniu
- Aktualizuj zewnętrzny system, gdy zmieniają się odpowiednie props lub stan
- 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:
- Używamy referencji (useRef) do przechowywania elementów DOM i instancji biblioteki zewnętrznej
- Inicjalizujemy mapę tylko raz i zapisujemy jej instancję
- Używamy oddzielnych efektów do obsługi różnych aspektów synchronizacji
- 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:
- Używaj osobnych efektów dla różnych aspektów synchronizacji
- Wykorzystuj referencje do przechowywania instancji zewnętrznych bibliotek
- 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:
- Zawsze anuluj subskrypcje w funkcji czyszczącej
- 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:
- Mockowanie zewnętrznych bibliotek
- Testowanie efektów czyszczących
- 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:
- Inicjalizuj zewnętrzne systemy po pierwszym renderowaniu
- Aktualizuj je, gdy zmieniają się odpowiednie dane
- Sprzątaj zasoby, gdy komponent jest odmontowywany
- Dziel efekty według ich odpowiedzialności
- Enkapsuluj logikę synchronizacji w dedykowanych hookach
- Minimalizuj zbędne reinicjalizacje
- 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: