Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Referencje z useRef
W tej lekcji8
W kosmicznej podróży przez React, czasami potrzebujemy utrzymywać pewne dane lub odniesienia do elementów DOM, które przetrwają między renderowaniami, ale nie powodują ponownego renderowania komponentu. Hook useRef jest jak magazyn na statku kosmicznym - pozwala przechowywać ważne rzeczy, które nie zmieniają się przy każdym manewrze statku.
Czym jest useRef?
Hook useRef jest jednym z wbudowanych hooków w React, który:
- Tworzy mutowalne pole referencji, które przetrwa przez cały cykl życia komponentu
- Nie powoduje ponownego renderowania komponentu przy zmianie jego wartości
- Może być używany do przechowywania odniesień do elementów DOM lub dowolnych innych wartości
Podstawowa składnia:
const refContainer = useRef(initialValue);Zwrócony obiekt refContainer ma właściwość .current, która jest inicjalizowana wartością początkową (initialValue). Wartość ta może być zmieniana bez wywoływania ponownego renderowania.
Główne przypadki użycia useRef
1. Dostęp do elementów DOM
Jednym z najpopularniejszych zastosowań useRef jest uzyskanie bezpośredniego dostępu do węzłów DOM:
function SpaceshipControls() {
// Utworzenie referencji
const thrusterControlRef = useRef(null);
// Funkcja używająca referencji do elementu DOM
const focusThrusterControl = () => {
// Dostęp do elementu DOM przez właściwość .current
thrusterControlRef.current.focus();
};
return (
<div className="control-panel">
<h2>Panel sterowania napędem</h2>
{/* Przypisanie referencji do elementu input */}
<input
ref={thrusterControlRef}
type="range"
min="0"
max="100"
className="thruster-slider"
/>
<button onClick={focusThrusterControl}>
Aktywuj kontrolę ciągu
</button>
</div>
);
}W tym przykładzie:
- Tworzymy referencję
thrusterControlRefza pomocąuseRef(null) - Przypisujemy tę referencję do elementu
inputza pomocą atrybuturef - Używamy referencji, aby wywołać metodę
focus()na elemencie DOM
2. Przechowywanie wartości mutable między renderowaniami
useRef może służyć do przechowywania wartości, które:
- Nie powinny powodować ponownego renderowania przy zmianie
- Muszą być stabilne przez cały cykl życia komponentu
function MissionTimer() {
const [seconds, setSeconds] = useState(0);
const timerIdRef = useRef(null);
// Funkcja rozpoczynająca timer
const startTimer = () => {
if (timerIdRef.current !== null) return; // Unikaj duplikacji timerów
timerIdRef.current = setInterval(() => {
setSeconds(s => s + 1);
}, 1000);
};
// Funkcja zatrzymująca timer
const stopTimer = () => {
clearInterval(timerIdRef.current);
timerIdRef.current = null;
};
// Czyszczenie interwału przy odmontowaniu
useEffect(() => {
return () => {
if (timerIdRef.current !== null) {
clearInterval(timerIdRef.current);
}
};
}, []);
return (
<div className="mission-timer">
<p>Czas misji: {seconds} sekund</p>
<button onClick={startTimer}>Start</button>
<button onClick={stopTimer}>Stop</button>
</div>
);
}W tym przykładzie używamy useRef do przechowywania ID interwału. Jest to idealne zastosowanie, ponieważ:
- Nie potrzebujemy ponownego renderowania przy zmianie ID interwału
- Musimy zachować ID między renderowaniami, aby móc zatrzymać interwał
- Wartość ta nie jest używana bezpośrednio w renderowanym JSX
3. Śledzenie poprzednich wartości
Jednym z ciekawych zastosowań useRef jest śledzenie poprzednich wartości props lub stanu:
function usePrevious(value) {
const ref = useRef();
// Aktualizacja ref.current po renderowaniu
useEffect(() => {
ref.current = value;
}, [value]);
// Zwraca poprzednią wartość (undefined podczas pierwszego renderowania)
return ref.current;
}
function AsteroidTracker({ asteroidId }) {
const [asteroidData, setAsteroidData] = useState(null);
// Śledzenie poprzedniego ID
const previousAsteroidId = usePrevious(asteroidId);
// Efekt, który loguje zmianę obserwowanego asteroidu
useEffect(() => {
if (previousAsteroidId !== asteroidId) {
console.log(`Zmiana śledzenia z asteroidy ${previousAsteroidId} na ${asteroidId}`);
// Tutaj moglibyśmy pobierać nowe dane o asteroidzie
}
}, [asteroidId, previousAsteroidId]);
// Renderowanie...
}Hook usePrevious używa useRef do przechowywania poprzedniej wartości. Aktualizacja referencji odbywa się w useEffect, który uruchamia się po renderowaniu, więc wartość zapisana w referencji jest zawsze o jeden cykl renderowania "opóźniona" względem bieżącej wartości.
4. Unikanie zbędnych efektów
useRef może pomóc w optymalizacji, pozwalając uniknąć zbędnych efektów:
function TelemetryMonitor({ shipId }) {
const [data, setData] = useState(null);
const [isConnected, setIsConnected] = useState(false);
// Przechowywanie ID, żeby uniknąć zbędnych zmian połączenia
const lastShipIdRef = useRef(shipId);
useEffect(() => {
// Sprawdzenie, czy ID statku rzeczywiście się zmieniło
if (lastShipIdRef.current === shipId && isConnected) {
console.log('Statek nie zmienił się, pomijam ponowne łączenie');
return;
}
// Aktualizacja ref z nowym ID
lastShipIdRef.current = shipId;
// Nawiązanie połączenia...
console.log(`Łączenie z telemetrią statku ${shipId}...`);
const connection = telemetryService.connect(shipId);
setIsConnected(true);
connection.onData(newData => {
setData(newData);
});
return () => {
console.log(`Rozłączanie telemetrii statku ${shipId}...`);
connection.disconnect();
setIsConnected(false);
};
}, [shipId]);
// Renderowanie...
}useRef vs useState - kiedy używać?
Różnica między useRef a useState jest kluczowa do zrozumienia:
| Aspekt | useRef | useState |
|---|---|---|
| Powoduje ponowne renderowanie | Nie | Tak |
| Zachowuje wartość między renderowaniami | Tak | Tak |
| Dostęp do wartości | Przez właściwość .current | Bezpośrednio przez odczytanie zmiennej stanu |
| Aktualizacja wartości | Bezpośrednia mutacja ref.current = newValue | Przez funkcję aktualizującą setState(newValue) |
| Kiedy użyć? | Dla wartości, które nie wpływają na wyjście renderowania | Dla wartości, które powinny powodować ponowne renderowanie |
Kiedy użyć useRef:
- Dostęp do elementów DOM
- Przechowywanie ID timerów i interwałów
- Przechowywanie poprzednich wartości
- Wartości, które zmieniają się często, ale nie wpływają na UI
- Przechowywanie instancji klas i obiektów, które nie powinny być tworzone przy każdym renderowaniu
Kiedy użyć useState:
- Dane, które wpływają na to, co widzi użytkownik
- Wartości, których zmiana powinna powodować aktualizację interfejsu
- Stan, który kontroluje zachowanie lub wygląd interfejsu użytkownika
Zaawansowane wzorce używania useRef
1. Callback Refs
Czasami potrzebujemy większej kontroli nad tym, kiedy ref jest przypisywany. W takich przypadkach możemy użyć callback ref:
function SpectrumAnalyzer() {
const [frequency, setFrequency] = useState(440);
let canvasRef = useRef(null);
// Funkcja callback dla ref, wywoływana gdy ref jest przypisany lub odłączony
const setCanvasRef = useCallback(element => {
// element będzie null podczas odmontowywania
if (element) {
canvasRef.current = element;
// Możemy teraz wykonać inicjalizację po przypisaniu referencji
initializeCanvas(element, frequency);
} else {
// Czyszczenie zasobów przy odmontowaniu
if (canvasRef.current) {
cleanupCanvas(canvasRef.current);
}
canvasRef.current = null;
}
}, [frequency]); // Zależność od frequency
// Funkcja inicjalizująca canvas
const initializeCanvas = (canvas, freq) => {
console.log(`Inicjalizacja analizatora dla częstotliwości ${freq} Hz`);
const ctx = canvas.getContext('2d');
// Rysowanie...
};
return (
<div>
<canvas
ref={setCanvasRef}
width="600"
height="300"
/>
<input
type="range"
min="20"
max="20000"
value={frequency}
onChange={e => setFrequency(Number(e.target.value))}
/>
<div>Częstotliwość: {frequency} Hz</div>
</div>
);
}Callback ref daje nam większą kontrolę, ponieważ jest wywoływany zarówno przy przypisywaniu, jak i przy usuwaniu referencji.
2. Łączenie useRef z forwardRef
Czasami chcemy przekazać referencję do komponentu potomnego. Możemy to zrobić za pomocą forwardRef:
// Komponent potomny
const NavigationControl = forwardRef((props, ref) => {
return (
<div className="nav-control">
<label>{props.label}</label>
<input
ref={ref}
type="text"
className="nav-input"
value={props.value}
onChange={props.onChange}
/>
</div>
);
});
// Komponent rodzic
function NavigationPanel() {
const destinationInputRef = useRef(null);
const [destination, setDestination] = useState('');
const focusDestination = () => {
// Możemy uzyskać dostęp do wewnętrznego inputa dzięki forwardRef
destinationInputRef.current.focus();
};
return (
<div className="nav-panel">
<h2>Panel nawigacyjny</h2>
<NavigationControl
ref={destinationInputRef}
label="Cel podróży:"
value={destination}
onChange={e => setDestination(e.target.value)}
/>
<button onClick={focusDestination}>
Ustaw cel
</button>
</div>
);
}forwardRef pozwala komponentowi otrzymać referencję od rodzica i przekazać ją do określonego elementu wewnątrz komponentu.
3. Przechowywanie wielu referencji
Czasami potrzebujemy śledzić wiele elementów, na przykład listę elementów:
function StarMap({ stars }) {
// Przechowywanie mapy referencji do gwiazd
const starRefs = useRef({});
// Funkcja do przewinięcia do określonej gwiazdy
const scrollToStar = (starId) => {
if (starRefs.current[starId]) {
starRefs.current[starId].scrollIntoView({
behavior: 'smooth',
block: 'center'
});
}
};
return (
<div className="star-map-container">
<div className="star-list">
{stars.map(star => (
<div
key={star.id}
// Zapisujemy referencję do elementu w naszej mapie
ref={el => starRefs.current[star.id] = el}
className="star-item"
>
<h3>{star.name}</h3>
<p>Typ: {star.type}</p>
<p>Odległość: {star.distance} lat świetlnych</p>
</div>
))}
</div>
<div className="star-navigator">
<h3>Szybka nawigacja</h3>
{stars.map(star => (
<button
key={star.id}
onClick={() => scrollToStar(star.id)}
>
{star.name}
</button>
))}
</div>
</div>
);
}W tym przykładzie przechowujemy mapę referencji, gdzie kluczem jest id gwiazdy, a wartością - referencja do odpowiedniego elementu DOM.
Typowe pułapki przy używaniu useRef
1. Próba renderowania bezpośrednio z ref.current
Ponieważ zmiana ref.current nie powoduje ponownego renderowania, próba wykorzystania tej wartości bezpośrednio w JSX może prowadzić do niespójności:
// ŹLE: Zmiana ref.current nie spowoduje aktualizacji interfejsu
function BadCounter() {
const countRef = useRef(0);
const increment = () => {
// Ta zmiana nie spowoduje ponownego renderowania
countRef.current += 1;
console.log(`Licznik: ${countRef.current}`); // Zostanie zalogowane prawidłowo
};
return (
<div>
<p>Licznik: {countRef.current}</p> {/* Nie zaktualizuje się po kliknięciu */}
<button onClick={increment}>Zwiększ</button>
</div>
);
}
// DOBRZE: Użyj useState dla wartości, które wpływają na renderowanie
function GoodCounter() {
const [count, setCount] = useState(0);
const increment = () => {
setCount(c => c + 1);
};
return (
<div>
<p>Licznik: {count}</p> {/* Zaktualizuje się po kliknięciu */}
<button onClick={increment}>Zwiększ</button>
</div>
);
}2. Zapominanie o .current
Częstym błędem jest zapominanie o dostępie do wartości poprzez .current:
// ŹLE: Brak .current
function MissionLog({ onAddLog }) {
const logInputRef = useRef(null);
const handleAddLog = () => {
// Błąd: Zapomnieliśmy o .current
const logText = logInputRef.value;
onAddLog(logText);
};
return (
<div>
<input ref={logInputRef} type="text" />
<button onClick={handleAddLog}>Dodaj wpis</button>
</div>
);
}
// DOBRZE: Używamy .current
function MissionLog({ onAddLog }) {
const logInputRef = useRef(null);
const handleAddLog = () => {
// Poprawne użycie .current
const logText = logInputRef.current.value;
onAddLog(logText);
logInputRef.current.value = '';
};
return (
<div>
<input ref={logInputRef} type="text" />
<button onClick={handleAddLog}>Dodaj wpis</button>
</div>
);
}3. Niewłaściwe użycie ref do sterowania renderowaniem
useRef nie jest odpowiednim narzędziem do kontrolowania, kiedy komponent powinien się renderować:
// ŹLE: Próba użycia ref do sterowania renderowaniem
function BadRenderControl() {
const shouldUpdateRef = useRef(false);
const forceUpdate = () => {
shouldUpdateRef.current = true;
// Brakuje mechanizmu wymuszającego ponowne renderowanie
};
console.log('Renderowanie', shouldUpdateRef.current);
// To nie zadziała jak oczekiwano
if (shouldUpdateRef.current) {
shouldUpdateRef.current = false;
// Jakieś operacje...
}
return <button onClick={forceUpdate}>Odśwież</button>;
}
// DOBRZE: Użycie useState do sterowania renderowaniem
function GoodRenderControl() {
const [update, setUpdate] = useState(0);
const didUpdateRef = useRef(false);
const forceUpdate = () => {
setUpdate(u => u + 1); // Wywołuje ponowne renderowanie
};
console.log('Renderowanie', update);
useEffect(() => {
if (update > 0) {
didUpdateRef.current = true;
// Operacje po aktualizacji...
}
}, [update]);
return <button onClick={forceUpdate}>Odśwież</button>;
}Najlepsze praktyki z useRef
Używaj useRef do wartości, które nie wpływają na render - jeśli zmiana wartości powinna powodować aktualizację interfejsu, użyj
useState.Zachowaj ostrożność przy bezpośredniej manipulacji DOM - manipulacja DOM przez referencje powinna być ograniczona i dobrze przemyślana.
Inicjalizuj refs z odpowiednią wartością początkową - na przykład
nulldla referencji DOM lub początkowa wartość dla liczników.Sprawdzaj czy ref.current istnieje przed użyciem - szczególnie w przypadku referencji DOM, które mogą być
nullpodczas pierwszego renderowania.Używaj useCallback dla funkcji tworzących referencje - jeśli przekazujesz funkcję referencji, rozważ owinięcie jej w
useCallbackdla optymalizacji.Unikaj nadużywania refs - chociaż refs są przydatne, nadmierne poleganie na nich może prowadzić do trudnego w utrzymaniu kodu.
Przykład praktyczny: Zaawansowany odtwarzacz wideo kosmicznej misji
Poniżej znajduje się bardziej złożony przykład, który pokazuje różne aspekty korzystania z useRef:
import React, { useState, useRef, useEffect, useCallback } from 'react';
function MissionVideoPlayer({ videoUrl, onProgress }) {
const [isPlaying, setIsPlaying] = useState(false);
const [duration, setDuration] = useState(0);
const [currentTime, setCurrentTime] = useState(0);
const [volume, setVolume] = useState(0.7);
// Referencje
const videoRef = useRef(null); // Referencja do elementu wideo
const progressBarRef = useRef(null); // Referencja do paska postępu
const animationFrameRef = useRef(null); // ID requestAnimationFrame do aktualizacji czasu
const isMountedRef = useRef(true); // Flaga, czy komponent jest zamontowany
const lastUpdateTimeRef = useRef(0); // Czas ostatniej aktualizacji dla throttlingu
// Funkcja inicjalizująca metadane wideo
const handleLoadedMetadata = () => {
if (videoRef.current) {
setDuration(videoRef.current.duration);
videoRef.current.volume = volume;
}
};
// Funkcja aktualizująca pasek postępu
const updateProgressBar = useCallback(() => {
if (!videoRef.current || !isMountedRef.current) return;
const now = Date.now();
if (now - lastUpdateTimeRef.current > 200) { // Throttling do 5 aktualizacji na sekundę
setCurrentTime(videoRef.current.currentTime);
onProgress(videoRef.current.currentTime);
lastUpdateTimeRef.current = now;
}
// Kontynuuj aktualizację jeśli wideo jest odtwarzane
if (videoRef.current.paused) return;
animationFrameRef.current = requestAnimationFrame(updateProgressBar);
}, [onProgress]);
// Start lub pauza odtwarzania
const togglePlayPause = () => {
if (!videoRef.current) return;
if (videoRef.current.paused) {
videoRef.current.play();
setIsPlaying(true);
animationFrameRef.current = requestAnimationFrame(updateProgressBar);
} else {
videoRef.current.pause();
setIsPlaying(false);
if (animationFrameRef.current) {
cancelAnimationFrame(animationFrameRef.current);
}
}
};
// Zmiana pozycji odtwarzania po kliknięciu paska postępu
const handleProgressBarClick = (e) => {
if (!progressBarRef.current || !videoRef.current) return;
const rect = progressBarRef.current.getBoundingClientRect();
const position = (e.clientX - rect.left) / rect.width;
const newTime = duration * Math.max(0, Math.min(1, position));
videoRef.current.currentTime = newTime;
setCurrentTime(newTime);
};
// Zmiana głośności
const handleVolumeChange = (e) => {
const newVolume = parseFloat(e.target.value);
setVolume(newVolume);
if (videoRef.current) {
videoRef.current.volume = newVolume;
}
};
// Efekt czyszczący animationFrame i ustawiający flagę montowania
useEffect(() => {
return () => {
isMountedRef.current = false;
if (animationFrameRef.current) {
cancelAnimationFrame(animationFrameRef.current);
}
};
}, []);
// Formatowanie czasu (mm:ss)
const formatTime = (timeInSeconds) => {
const minutes = Math.floor(timeInSeconds / 60);
const seconds = Math.floor(timeInSeconds % 60);
return `${minutes}:${seconds < 10 ? '0' : ''}${seconds}`;
};
return (
<div className="mission-video-player">
<video
ref={videoRef}
src={videoUrl}
onLoadedMetadata={handleLoadedMetadata}
onEnded={() => setIsPlaying(false)}
/>
<div className="controls">
<button onClick={togglePlayPause}>
{isPlaying ? 'Pauza' : 'Odtwórz'}
</button>
<div className="time-display">
{formatTime(currentTime)} / {formatTime(duration)}
</div>
<div
ref={progressBarRef}
className="progress-bar"
onClick={handleProgressBarClick}
>
<div
className="progress-fill"
style={{ width: `${(currentTime / duration) * 100}%` }}
/>
</div>
<div className="volume-control">
<label>Głośność:</label>
<input
type="range"
min="0"
max="1"
step="0.05"
value={volume}
onChange={handleVolumeChange}
/>
</div>
</div>
</div>
);
}Ten przykład pokazuje kilka zaawansowanych aspektów pracy z useRef:
Wiele różnych zastosowań referencji:
- Dostęp do elementu DOM (
videoRef,progressBarRef) - Przechowywanie ID animacji (
animationFrameRef) - Flaga montowania (
isMountedRef) - Śledzenie wartości dla throttlingu (
lastUpdateTimeRef)
- Dostęp do elementu DOM (
Integracja referencji z efektami i callbackami
Bezpośrednia manipulacja elementem wideo przez jego API
Throttling aktualizacji stanu za pomocą referencji czasu
Podsumowanie
Hook useRef jest niezbędnym narzędziem w zestawie React, szczególnie przydatnym do:
- Przechowywania referencji do elementów DOM
- Utrzymywania wartości między renderowaniami bez wywoływania ponownego renderowania
- Śledzenia poprzednich wartości
- Przechowywania ID timerów, interwałów i requestAnimationFrame
- Przechowywania flag i wartości, które nie wpływają bezpośrednio na interfejs
Kluczem do efektywnego wykorzystania useRef jest zrozumienie, kiedy używać go zamiast useState. Zasadnicza różnica polega na tym, że useRef nie powoduje ponownego renderowania przy zmianie wartości, co czyni go idealnym wyborem dla operacji, które nie powinny wpływać na cykl renderowania.
W naszej kosmicznej podróży przez React, useRef jest jak magazyn lub schowek na statku - miejsce, gdzie możesz przechowywać rzeczy, które potrzebujesz mieć pod ręką, ale które nie wymagają uwagi całej załogi za każdym razem, gdy się zmieniają.
Kod do tej lekcji: App.jsx
import React, { useState, useRef, useEffect } from 'react';
// useRef do przechowywania referencji do elementów DOM
function DOMReferenceDemo() {
const inputRef = useRef(null);
const canvasRef = useRef(null);
const focusInput = () => {
inputRef.current?.focus();
};
const drawOnCanvas = () => {
const canvas = canvasRef.current;
if (!canvas) return;
const ctx = canvas.getContext('2d');
ctx.clearRect(0, 0, canvas.width, canvas.height);
// Rysowanie gwiazd
for (let i = 0; i < 50; i++) {
const x = Math.random() * canvas.width;
const y = Math.random() * canvas.height;
const radius = Math.random() * 2;
ctx.beginPath();
ctx.arc(x, y, radius, 0, Math.PI * 2);
ctx.fillStyle = `rgba(255, 255, 255, ${Math.random()})`;
ctx.fill();
}
// Rysowanie planety
ctx.beginPath();
ctx.arc(canvas.width / 2, canvas.height / 2, 30, 0, Math.PI * 2);
ctx.fillStyle = '#61dafb';
ctx.fill();
};
return (
<div className="demo-card">
<h2>Referencje DOM</h2>
<div className="input-section">
<input ref={inputRef} type="text" placeholder="Kliknij przycisk poniżej" />
<button onClick={focusInput}>Fokus na input</button>
</div>
<div className="canvas-section">
<canvas ref={canvasRef} width={280} height={150} />
<button onClick={drawOnCanvas}>Rysuj kosmos</button>
</div>
</div>
);
}
// useRef do przechowywania wartości między renderami
function PreviousValueDemo() {
const [count, setCount] = useState(0);
const prevCountRef = useRef(0);
useEffect(() => {
prevCountRef.current = count;
});
return (
<div className="demo-card">
<h2>Poprzednia wartość</h2>
<div className="values">
<div className="value-box">
<span className="label">Aktualna:</span>
<span className="number current">{count}</span>
</div>
<div className="value-box">
<span className="label">Poprzednia:</span>
<span className="number previous">{prevCountRef.current}</span>
</div>
</div>
<button onClick={() => setCount(c => c + 1)}>Zwiększ</button>
</div>
);
}
// useRef do mierzenia elementów
function MeasurementDemo() {
const boxRef = useRef(null);
const [dimensions, setDimensions] = useState({ width: 0, height: 0 });
const [boxSize, setBoxSize] = useState(100);
const measureBox = () => {
if (boxRef.current) {
const rect = boxRef.current.getBoundingClientRect();
setDimensions({ width: rect.width, height: rect.height });
}
};
return (
<div className="demo-card">
<h2>Pomiary elementów</h2>
<div
ref={boxRef}
className="measure-box"
style={{ width: boxSize, height: boxSize }}
>
{boxSize}x{boxSize}
</div>
<div className="measurement-info">
Zmierzono: {dimensions.width.toFixed(0)} x {dimensions.height.toFixed(0)}
</div>
<div className="controls">
<button onClick={() => setBoxSize(s => Math.max(50, s - 20))}></button>
<button onClick={measureBox}>Zmierz</button>
<button onClick={() => setBoxSize(s => Math.min(200, s + 20))}></button>
</div>
</div>
);
}
// useRef do przechowywania timeoutów/intervalów
function TimerRefDemo() {
const [time, setTime] = useState(0);
const [isRunning, setIsRunning] = useState(false);
const intervalRef = useRef(null);
const start = () => {
if (intervalRef.current) return;
setIsRunning(true);
intervalRef.current = setInterval(() => {
setTime(t => t + 1);
}, 100);
};
const stop = () => {
if (intervalRef.current) {
clearInterval(intervalRef.current);
intervalRef.current = null;
}
setIsRunning(false);
};
const reset = () => {
stop();
setTime(0);
};
// Cleanup przy odmontowaniu
useEffect(() => {
return () => {
if (intervalRef.current) {
clearInterval(intervalRef.current);
}
};
}, []);
const formatTime = (t) => {
const seconds = Math.floor(t / 10);
const decimals = t % 10;
return `${seconds}.${decimals}s`;
};
return (
<div className="demo-card">
<h2>⏱Timer z useRef</h2>
<div className="timer-display">{formatTime(time)}</div>
<div className="controls">
<button onClick={start} disabled={isRunning}>▶Start</button>
<button onClick={stop} disabled={!isRunning}>⏸Pauza</button>
<button onClick={reset}>Reset</button>
</div>
<p className="hint">Interval ID przechowywany w useRef</p>
</div>
);
}
function App() {
return (
<div className="app">
<h1>useRef Hook</h1>
<p className="subtitle">Referencje i wartości poza cyklem renderowania</p>
<div className="demos">
<DOMReferenceDemo />
<PreviousValueDemo />
<MeasurementDemo />
<TimerRefDemo />
</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. Co zawiera tablica zależności (dependency array) w useEffect?
2. Które z poniższych jest przykładem efektu ubocznego (side effect) w React?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż elementy deklaracji useRef od lewej do prawej:
- Układanie w pionie
Uporządkuj kroki prawidłowego użycia async/await wewnątrz useEffect:
- Klikanie w kolejności
Uporządkuj async operacje w useEffect:
- Edytor kodu
Śledzenie pozycji geolokalizacji