Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Przechowywanie wartości między renderowaniami z useRef
W tej lekcji6
Wyobraź sobie taką sytuację: chcesz zapamiętać identyfikator timera misji albo poprzednią prędkość statku. Zwykła zmienna w komponencie odpada, bo przy każdym renderowaniu funkcja komponentu wykonuje się od nowa i zmienna wraca do wartości początkowej. useState zapamięta wartość, ale każda jej zmiana wywoła ponowne renderowanie, choć ekran wcale nie musi się zmienić. Potrzebujemy czegoś pośrodku.
W kosmicznej podróży przez React, czasami potrzebujemy przechowywać informacje, które przetrwają między renderowaniami komponentu, ale nie powinny powodować ponownego renderowania. Hook useRef jest jak kapsuła ratunkowa - przechowuje dane, które możesz odzyskać w dowolnym momencie, bez względu na to, ile razy twój statek kosmiczny (komponent) zostanie przebudowany.
Czym jest useRef?
Hook useRef tworzy mutowalny obiekt referencyjny, którego właściwość .current jest inicjalizowana przekazaną wartością. Ważną cechą useRef jest to, że:
- Wartość przechowywana w referencji pozostaje taka sama między renderowaniami
- Zmiana wartości referencji NIE powoduje ponownego renderowania komponentu
- Działa jak "magazyn pamięci", do którego możesz się odwoływać w dowolnym momencie w cyklu życia komponentu
Dokumentacja react.dev dodaje dwa szczegóły. Po pierwsze, useRef przy każdym renderowaniu zwraca ten sam obiekt, a wartość początkowa jest używana tylko przy pierwszym renderze. Po drugie, .current zmieniasz zwykłym przypisaniem, bez żadnej funkcji typu setter.
useRef vs useState - kluczowe różnice
Porównajmy dwie kluczowe metody przechowywania danych w komponentach. W poniższym panelu prędkość trzymamy w stanie, a poprzednią prędkość w referencji, którą aktualizuje useEffect po każdej zmianie:
function SpaceshipDashboard() {
// Stan - zmiany powodują ponowne renderowanie
const [speed, setSpeed] = useState(0);
// Referencja - zmiany NIE powodują ponownego renderowania
const previousSpeedRef = useRef(0);
// Przy zmianie prędkości, zapisujemy poprzednią wartość
useEffect(() => {
previousSpeedRef.current = speed;
}, [speed]);
const increaseSpeed = () => {
setSpeed(speed + 10); // To spowoduje ponowne renderowanie
};
return (
<div>
<p>Aktualna prędkość: {speed} km/h</p>
<p>Poprzednia prędkość: {previousSpeedRef.current} km/h</p>
<button onClick={increaseSpeed}>Zwiększ prędkość</button>
</div>
);
}Kliknięcie zmienia stan, więc komponent renderuje się ponownie. W trakcie tego renderu referencja ma jeszcze starą wartość, bo efekt uruchamia się dopiero po wyrenderowaniu. Dlatego na ekranie widzisz poprzednią prędkość. Samo przypisanie do previousSpeedRef.current w efekcie niczego nie odświeża.
Ważne zastrzeżenie: react.dev zaleca, żeby nie czytać ani nie zapisywać ref.current w trakcie renderowania (wyjątkiem jest leniwa inicjalizacja). Ten wzorzec działa w prostym panelu, ale jest kruchy. Jeśli poprzednia wartość ma być widoczna na ekranie, dokumentacja poleca trzymać ją w stanie. Referencję zostaw na dane, których ekran nie pokazuje.
Typowe przypadki użycia useRef
1. Przechowywanie poprzednich wartości
Jednym z najpopularniejszych zastosowań useRef jest zapamiętywanie poprzednich wartości między renderowaniami. Tracker asteroidy liczy, o ile obiekt przesunął się od ostatniego renderu:
function AsteroidTracker({ asteroid }) {
const [position, setPosition] = useState({ x: 0, y: 0 });
const previousPositionRef = useRef({ x: 0, y: 0 });
useEffect(() => {
// Zapisujemy aktualną pozycję jako poprzednią przed następną aktualizacją
previousPositionRef.current = position;
}, [position]);
// Obliczamy, jak daleko poruszył się asteroid
const distanceMoved = Math.sqrt(
Math.pow(position.x - previousPositionRef.current.x, 2) +
Math.pow(position.y - previousPositionRef.current.y, 2)
);
return (
<div>
<p>Aktualna pozycja: ({position.x}, {position.y})</p>
<p>Poprzednia pozycja: ({previousPositionRef.current.x}, {previousPositionRef.current.y})</p>
<p>Przebyta odległość: {distanceMoved}</p>
</div>
);
}Mechanizm jest ten sam co w panelu prędkości: efekt zapisuje pozycję po renderze, a obliczenie korzysta z wartości z poprzedniego renderu. Obowiązuje tu też to samo zastrzeżenie o czytaniu referencji podczas renderowania.
2. Liczniki i wartości instancji, które nie wpływają na renderowanie
Tu useRef naprawdę błyszczy. Czas misji i identyfikator interwału to dane, które zmieniają się co sekundę, ale nie są wyświetlane na bieżąco:
function MissionControl() {
const missionTimeRef = useRef(0);
const timerIdRef = useRef(null);
// Rozpoczęcie licznika misji
const startMissionTimer = () => {
if (timerIdRef.current !== null) return; // Unikamy wielokrotnego uruchamiania
timerIdRef.current = setInterval(() => {
missionTimeRef.current += 1;
console.log(`Czas misji: ${missionTimeRef.current} sekund`);
// Zauważ, że to NIE powoduje ponownego renderowania komponentu
}, 1000);
};
// Zatrzymanie licznika misji
const stopMissionTimer = () => {
clearInterval(timerIdRef.current);
timerIdRef.current = null;
};
// Czyszczenie przy odmontowaniu komponentu
useEffect(() => {
return () => {
if (timerIdRef.current !== null) {
clearInterval(timerIdRef.current);
}
};
}, []);
return (
<div>
<button onClick={startMissionTimer}>Rozpocznij misję</button>
<button onClick={stopMissionTimer}>Zakończ misję</button>
<button onClick={() => alert(`Czas misji: ${missionTimeRef.current} sekund`)}>
Pokaż czas misji
</button>
</div>
);
}Licznik rośnie co sekundę, konsola to potwierdza, a komponent nie renderuje się ani razu. Referencje czytamy wyłącznie w funkcjach obsługi zdarzeń i w efekcie, czyli dokładnie tam, gdzie zaleca dokumentacja. Przyciski i ich wygląd pozostają niezmienione przez całą misję.
3. Dostęp do elementów DOM
Trzecie zastosowanie to uchwyt do prawdziwego elementu na stronie. Przekazujesz referencję w atrybucie ref, a React po wyrenderowaniu zapisze w .current węzeł DOM:
function SpaceshipScanner() {
const scannerInputRef = useRef(null);
const focusScannerInput = () => {
// Bezpośredni dostęp do elementu DOM
scannerInputRef.current.focus();
};
return (
<div>
<input
ref={scannerInputRef}
type="text"
placeholder="Wprowadź współrzędne..."
/>
<button onClick={focusScannerInput}>Aktywuj skaner</button>
</div>
);
}Kliknięcie przycisku ustawia kursor w polu współrzędnych. React nie tworzy tu nowego pola, tylko daje ci dostęp do istniejącego. W React 19 możesz też przekazać ref jako zwykły prop do własnego komponentu funkcyjnego, bez forwardRef.
useRef a useCallback
Oba hooki coś "zapamiętują", ale co innego. useRef trzyma dowolną wartość, którą sam zmieniasz. useCallback zapamiętuje funkcję i tworzy nową dopiero wtedy, gdy zmieni się któraś z zależności:
const handleClick = useCallback(() => {
onClick(id);
}, [id, onClick]);Kolejność jest zawsze taka sama: funkcja, potem tablica zależności. Dopóki id i onClick się nie zmienią, handleClick pozostaje tym samym obiektem funkcji.
Pamiętaj o zasadach używania useRef
- Nie nadużywaj go: Używaj useRef tylko wtedy, gdy wartość naprawdę nie powinna powodować ponownego renderowania
- Unikaj bezpośrednich mutacji DOM: Chociaż useRef daje ci dostęp do elementów DOM, używaj go oszczędnie i zgodnie z filozofią Reacta
- Pamiętaj o czyszczeniu: Jeśli używasz useRef do przechowywania timerów lub subskrypcji, pamiętaj o ich czyszczeniu w funkcji czyszczącej useEffect
Moja rada: zanim sięgniesz po referencję, zapytaj, czy ta wartość ma być widoczna na ekranie. Jeśli tak, użyj stanu. Jeśli nie, referencja będzie lżejsza.
Podsumowanie
Hook useRef jest nieoceniony, gdy potrzebujesz:
- Przechować wartość między renderowaniami bez powodowania ponownego renderowania
- Śledzić poprzednie wartości
- Uzyskać bezpośredni dostęp do elementów DOM
- Przechowywać identyfikatory timerów lub inne wartości instancji
W następnej lekcji zbudujemy własne hooki, w których referencje często ukrywają szczegóły, na przykład timery.
Jak kapsuła ratunkowa w kosmosie, useRef przechowuje cenne dane, które mogą być potrzebne w krytycznych momentach misji twojego komponentu.
Kod do tej lekcji: App.jsx
import React, { useState, useRef, useEffect } from 'react';
// Śledzenie poprzednich wartości
function PreviousValueTracker() {
const [position, setPosition] = useState({ x: 0, y: 0 });
const prevPositionRef = useRef({ x: 0, y: 0 });
useEffect(() => {
prevPositionRef.current = position;
});
const move = (dx, dy) => {
setPosition(prev => ({
x: Math.max(-100, Math.min(100, prev.x + dx)),
y: Math.max(-100, Math.min(100, prev.y + dy))
}));
};
return (
<div className="demo-card">
<h2>Sledzenie pozycji</h2>
<div className="position-display">
<div className="current">
<h3>Aktualna</h3>
<p>X: {position.x}</p>
<p>Y: {position.y}</p>
</div>
<div className="previous">
<h3>Poprzednia</h3>
<p>X: {prevPositionRef.current.x}</p>
<p>Y: {prevPositionRef.current.y}</p>
</div>
</div>
<div className="controls">
<button onClick={() => move(0, -10)}>UP</button>
<div className="horizontal">
<button onClick={() => move(-10, 0)}>LEFT</button>
<button onClick={() => move(10, 0)}>RIGHT</button>
</div>
<button onClick={() => move(0, 10)}>DOWN</button>
</div>
</div>
);
}
// Licznik renderow
function RenderCounter() {
const renderCountRef = useRef(0);
const [value, setValue] = useState('');
renderCountRef.current++;
return (
<div className="demo-card">
<h2>Licznik renderow</h2>
<div className="render-count">
Rendery: <span>{renderCountRef.current}</span>
</div>
<input
value={value}
onChange={(e) => setValue(e.target.value)}
placeholder="Pisz, aby wywolac render..."
/>
<p className="hint">
useRef przechowuje wartosc bez ponownego renderowania
</p>
</div>
);
}
// Porownanie obiektow
function ObjectComparisonDemo() {
const [user, setUser] = useState({ name: 'Astronauta', level: 1 });
const prevUserRef = useRef(user);
const [changes, setChanges] = useState([]);
useEffect(() => {
const changedFields = [];
if (prevUserRef.current.name !== user.name) {
changedFields.push(`name: "${prevUserRef.current.name}" -> "${user.name}"`);
}
if (prevUserRef.current.level !== user.level) {
changedFields.push(`level: ${prevUserRef.current.level} -> ${user.level}`);
}
if (changedFields.length > 0) {
setChanges(prev => [...prev.slice(-4), ...changedFields]);
}
prevUserRef.current = user;
}, [user]);
return (
<div className="demo-card">
<h2>Porownanie zmian</h2>
<div className="user-info">
<input
value={user.name}
onChange={(e) => setUser(prev => ({ ...prev, name: e.target.value }))}
placeholder="Imie"
/>
<div className="level-controls">
<button onClick={() => setUser(prev => ({ ...prev, level: Math.max(1, prev.level - 1) }))}>
-
</button>
<span>Level: {user.level}</span>
<button onClick={() => setUser(prev => ({ ...prev, level: prev.level + 1 }))}>
+
</button>
</div>
</div>
<div className="changes">
<h4>Historia zmian:</h4>
{changes.map((change, i) => (
<div key={i} className="change">{change}</div>
))}
</div>
</div>
);
}
// Cache wartosci obliczeniowych
function ComputationCacheDemo() {
const [numbers, setNumbers] = useState([1, 2, 3, 4, 5]);
const [multiplier, setMultiplier] = useState(2);
const cacheRef = useRef(new Map());
const cacheHits = useRef(0);
const cacheMisses = useRef(0);
const computeExpensive = (num, mult) => {
const key = `${num}-${mult}`;
if (cacheRef.current.has(key)) {
cacheHits.current += 1;
return cacheRef.current.get(key);
}
// Symulacja kosztownej operacji
const result = num * mult;
cacheRef.current.set(key, result);
cacheMisses.current += 1;
return result;
};
const results = numbers.map(n => computeExpensive(n, multiplier));
const addNumber = () => {
setNumbers(prev => [...prev, prev.length + 1]);
};
return (
<div className="demo-card">
<h2>Cache z useRef</h2>
<div className="cache-stats">
<span className="hit">Trafienia: {cacheHits.current}</span>
<span className="miss">Pudla: {cacheMisses.current}</span>
</div>
<div className="multiplier">
<button onClick={() => setMultiplier(m => Math.max(1, m - 1))}>-</button>
<span>Mnoznik: {multiplier}</span>
<button onClick={() => setMultiplier(m => m + 1)}>+</button>
</div>
<div className="numbers">
{numbers.map((n, i) => (
<div key={i} className="number-result">
{n} x {multiplier} = {results[i]}
</div>
))}
</div>
<button onClick={addNumber}>+ Dodaj liczbe</button>
</div>
);
}
function App() {
return (
<div className="app">
<h1>Przechowywanie wartosci z useRef</h1>
<div className="demos">
<PreviousValueTracker />
<RenderCounter />
<ObjectComparisonDemo />
<ComputationCacheDemo />
</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 poziomie
Ułóż poprawną składnię useCallback dla handlera zdarzenia: