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

Referencje z useRef

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

  1. Tworzy mutowalne pole referencji, które przetrwa przez cały cykl życia komponentu
  2. Nie powoduje ponownego renderowania komponentu przy zmianie jego wartości
  3. 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:

  1. Tworzymy referencję thrusterControlRef za pomocą useRef(null)
  2. Przypisujemy tę referencję do elementu input za pomocą atrybutu ref
  3. 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:

AspektuseRefuseState
Powoduje ponowne renderowanieNieTak
Zachowuje wartość między renderowaniamiTakTak
Dostęp do wartościPrzez właściwość .currentBezpośrednio przez odczytanie zmiennej stanu
Aktualizacja wartościBezpośrednia mutacja ref.current = newValuePrzez funkcję aktualizującą setState(newValue)
Kiedy użyć?Dla wartości, które nie wpływają na wyjście renderowaniaDla 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

  1. 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.

  2. Zachowaj ostrożność przy bezpośredniej manipulacji DOM - manipulacja DOM przez referencje powinna być ograniczona i dobrze przemyślana.

  3. Inicjalizuj refs z odpowiednią wartością początkową - na przykład null dla referencji DOM lub początkowa wartość dla liczników.

  4. Sprawdzaj czy ref.current istnieje przed użyciem - szczególnie w przypadku referencji DOM, które mogą być null podczas pierwszego renderowania.

  5. Używaj useCallback dla funkcji tworzących referencje - jeśli przekazujesz funkcję referencji, rozważ owinięcie jej w useCallback dla optymalizacji.

  6. 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:

  1. 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)
  2. Integracja referencji z efektami i callbackami

  3. Bezpośrednia manipulacja elementem wideo przez jego API

  4. 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. 1. Co zawiera tablica zależności (dependency array) w useEffect?

  2. 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

  1. PytanieTablica zależności w useEffect
  2. PytanieEfekty uboczne w React
  3. Ułóż w kolejnościSkładnia useRef
  4. Ułóż w kolejnościWzorzec async w useEffect
  5. Kliknij w kolejnościAsync operations w useEffect
  6. Zadanie z kodemPraktyka: Geolocation API

Przydatne artykuły