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

Przechowywanie wartości między renderowaniami z useRef

6 min czytania ·
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:

  1. Wartość przechowywana w referencji pozostaje taka sama między renderowaniami
  2. Zmiana wartości referencji NIE powoduje ponownego renderowania komponentu
  3. 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

  1. Nie nadużywaj go: Używaj useRef tylko wtedy, gdy wartość naprawdę nie powinna powodować ponownego renderowania
  2. 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
  3. 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:

  1. Ułóż w kolejnościSkładnia useCallback z handlerem

Przydatne artykuły