Kurs JavaScript i React · Moduł 12: React i TypeScript

Typowanie useState i useRef

5 min czytania ·
W tej lekcji5

Lista planet startuje pusta, wybrana planeta na początku nie istnieje, a pole wyszukiwania trzeba ustawić w fokusie po kliknięciu. Bez typów każda z tych sytuacji kończy się pytaniem "co tu właściwie jest?". Hooki React to silniki Twojego kosmicznego statku. TypeScript pozwala określić, jakie dane przepływają przez te silniki, zapewniając bezpieczną nawigację.

Typowanie useState

Hook useState automatycznie dedukuje typ na podstawie wartości początkowej, ale czasem potrzebujesz jawnego typowania. Jawny typ podajesz w nawiasach ostrych zaraz po nazwie hooka, na przykład useState<string> - to tak zwany parametr generyczny. Zacznijmy od przypadków, w których nie trzeba nic pisać:

import { useState } from 'react';

// Automatyczna dedukcja typu
const [count, setCount] = useState(0);         // number
const [name, setName] = useState("Apollo");    // string
const [active, setActive] = useState(true);    // boolean

TypeScript patrzy na 0, "Apollo" i true i ustala typ stanu na zawsze. Wywołanie setCount("dużo") zostanie odrzucone, choć nigdzie nie napisaliśmy słowa number.

Inaczej jest, gdy wartość początkowa nie zdradza docelowego typu. Wybrana planeta na starcie to null, a z samego null kompilator nie wywnioskuje, że później pojawi się tam obiekt Planet. Wtedy podajemy union type Planet | null:

// Jawne typowanie - potrzebne gdy początkowa wartość to null lub undefined
interface Planet {
  id: number;
  name: string;
  type: string;
}

// Stan może być Planet lub null
const [selectedPlanet, setSelectedPlanet] = useState<Planet | null>(null);

// Tablica obiektów - pusta tablica nie mówi TypeScript o typie elementów
const [planets, setPlanets] = useState<Planet[]>([]);

// Union types
type Status = "idle" | "loading" | "success" | "error";
const [status, setStatus] = useState<Status>("idle");

Co się NIE zmieniło: w działającej aplikacji useState zachowuje się dokładnie tak samo. Generyk tylko mówi kompilatorowi, jakie wartości wolno przekazać do settera. Dzięki Status literówka setStatus("loadnig") nie przejdzie.

Kiedy jawne typowanie jest konieczne?

Poniżej ściąga czterech sytuacji, w których warto podać typ. Występuje w niej interfejs User - to zwykły interfejs użytkownika, zbudowany tak samo jak Planet. Nowy jest też interfejs FormData z polem opcjonalnym, które znasz z poprzedniej lekcji.

// 1. Początkowa wartość null/undefined
const [user, setUser] = useState<User | null>(null);

// 2. Pusta tablica
const [items, setItems] = useState<string[]>([]);

// 3. Union types z ograniczonymi wartościami
const [theme, setTheme] = useState<"dark" | "light">("dark");

// 4. Złożony obiekt z opcjonalnymi polami
interface FormData {
  name: string;
  email: string;
  message?: string;
}
const [form, setForm] = useState<FormData>({ name: "", email: "" });

W punkcie 3 bez generyka TypeScript uznałby theme za dowolny string. W punkcie 4 generyk pozwala pominąć message na starcie i dodać je później. Rada praktyczna: gdy wartość początkowa jasno pokazuje typ, nie pisz generyka - im mniej szumu, tym czytelniejszy kod.

Typowanie useRef

Hook useRef służy do przechowywania referencji do elementów DOM lub wartości, które nie powodują ponownego renderowania. Dla elementów DOM podajesz typ elementu przeglądarki, na przykład HTMLInputElement dla pola tekstowego, a jako wartość początkową null, bo element jeszcze nie istnieje w chwili pierwszego renderu:

import { useRef } from 'react';

// Referencja do elementu DOM
const inputRef = useRef<HTMLInputElement>(null);
const divRef = useRef<HTMLDivElement>(null);
const canvasRef = useRef<HTMLCanvasElement>(null);

W React 19 argument useRef jest obowiązkowy - samo useRef<HTMLInputElement>() zgłosi błąd typów. Tak wygląda referencja w komponencie. Operator ?. (optional chaining) wywołuje metodę tylko wtedy, gdy wartość po lewej nie jest null ani undefined:

function SearchBar() {
  const inputRef = useRef<HTMLInputElement>(null);

  const focusInput = () => {
    // inputRef.current może być null, więc używamy ?.
    inputRef.current?.focus();
  };

  return (
    <div>
      <input ref={inputRef} placeholder="Szukaj planety..." />
      <button onClick={focusInput}>Fokus</button>
    </div>
  );
}

React wpisuje element do inputRef.current po zamontowaniu komponentu, dlatego typ current to HTMLInputElement | null. Atrybut ref w JSX akceptuje tę referencję bez dodatkowych rzutowań.

useRef jako "kontener" na wartość

useRef może również przechowywać dowolną wartość, która nie powoduje ponownego renderowania - identyfikator timera, poprzednią wartość, licznik wywołań. Zmiana current nie odświeża ekranu, w przeciwieństwie do settera z useState.

// Timer ID
const timerRef = useRef<number | null>(null);

function Countdown() {
  const timerRef = useRef<number | null>(null);
  const [seconds, setSeconds] = useState(10);

  const start = () => {
    timerRef.current = window.setInterval(() => {
      setSeconds(prev => prev - 1);
    }, 1000);
  };

  const stop = () => {
    if (timerRef.current !== null) {
      clearInterval(timerRef.current);
      timerRef.current = null;
    }
  };

  return (
    <div>
      <p>Odliczanie: {seconds}s</p>
      <button onClick={start}>Start</button>
      <button onClick={stop}>Stop</button>
    </div>
  );
}

// Poprzednia wartość
const prevValueRef = useRef<string>("");

Dlaczego window.setInterval, a nie samo setInterval? W przeglądarce funkcja zwraca liczbę, ale gdy w projekcie są też typy Node.js, samo setInterval bywa typowane jako obiekt Timeout. Przedrostek window. rozwiewa tę wątpliwość i pasuje do number | null. W React 19 wszystkie referencje są modyfikowalne, więc przypisanie do timerRef.current jest w pełni legalne.

Typowe elementy HTML w useRef

Na koniec ściąga typów elementów, które najczęściej trafiają do referencji. Nazwa zawsze zaczyna się od HTML i kończy na Element:

// Najczęściej używane typy elementów
const inputRef = useRef<HTMLInputElement>(null);
const textareaRef = useRef<HTMLTextAreaElement>(null);
const selectRef = useRef<HTMLSelectElement>(null);
const buttonRef = useRef<HTMLButtonElement>(null);
const formRef = useRef<HTMLFormElement>(null);
const divRef = useRef<HTMLDivElement>(null);
const imgRef = useRef<HTMLImageElement>(null);
const videoRef = useRef<HTMLVideoElement>(null);

Nie musisz ich zapamiętywać - edytor podpowie nazwę po wpisaniu HTML. Te same typy elementów spotkasz w następnej lekcji jako parametr typów zdarzeń.

Kod do tej lekcji: App.tsx
import React, { useState, useRef } from 'react';

// Interfejs planety
interface Planet {
  id: number;
  name: string;
  type: string;
  distanceLy: number;
}

function App() {
  // useState z automatyczna dedukcja
  const [count, setCount] = useState(0);

  // useState z jawnym typem - poczatkowa wartosc null
  const [selectedPlanet, setSelectedPlanet] = useState<Planet | null>(null);

  // useState z tablica obiektow
  const [planets, setPlanets] = useState<Planet[]>([
    { id: 1, name: "Mars", type: "skalista", distanceLy: 0.000024 },
    { id: 2, name: "Jupiter", type: "gazowa", distanceLy: 0.000082 },
    { id: 3, name: "Kepler-442b", type: "skalista", distanceLy: 1206 },
  ]);

  // useState z union type
  const [status, setStatus] = useState<"idle" | "scanning" | "complete">("idle");

  // useRef do elementu DOM
  const searchRef = useRef<HTMLInputElement>(null);

  // useRef jako kontener na wartosc (timer)
  const scanTimerRef = useRef<number | null>(null);

  const focusSearch = () => {
    searchRef.current?.focus();
  };

  const startScan = () => {
    setStatus("scanning");
    scanTimerRef.current = window.setTimeout(() => {
      setStatus("complete");
      setCount(prev => prev + 1);
    }, 2000);
  };

  const cancelScan = () => {
    if (scanTimerRef.current !== null) {
      clearTimeout(scanTimerRef.current);
      scanTimerRef.current = null;
      setStatus("idle");
    }
  };

  const statusColors = {
    idle: "#9ca3af",
    scanning: "#f59e0b",
    complete: "#22c55e"
  };

  return (
    <div className="app">
      <h1>Skaner Kosmiczny</h1>

      <div className="status-bar">
        <span style={{ color: statusColors[status] }}>
          Status: {status.toUpperCase()}
        </span>
        <span>Ukonczone skany: {count}</span>
      </div>

      <div className="controls">
        <input ref={searchRef} placeholder="Szukaj planety..." className="search" />
        <button onClick={focusSearch}>Fokus</button>
        <button onClick={startScan} disabled={status === "scanning"}>
          {status === "scanning" ? "Skanowanie..." : "Skanuj"}
        </button>
        {status === "scanning" && (
          <button onClick={cancelScan} className="cancel">Anuluj</button>
        )}
      </div>

      <div className="planets">
        {planets.map(planet => (
          <div
            key={planet.id}
            className={"planet-card " + (selectedPlanet?.id === planet.id ? "selected" : "")}
            onClick={() => setSelectedPlanet(planet)}
          >
            <h3>{planet.name}</h3>
            <p>Typ: {planet.type}</p>
            <p>Odleglosc: {planet.distanceLy} ly</p>
          </div>
        ))}
      </div>

      {selectedPlanet && (
        <div className="detail">
          <h2>Wybrana: {selectedPlanet.name}</h2>
          <p>Typ: {selectedPlanet.type}</p>
          <p>Odleglosc: {selectedPlanet.distanceLy} lat swietlnych</p>
          <button onClick={() => setSelectedPlanet(null)}>Zamknij</button>
        </div>
      )}
    </div>
  );
}

export default App;

Pamiętaj: useState napędza to, co widzi załoga na ekranie, a useRef pracuje cicho w maszynowni - oba zasługują na precyzyjny typ.

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. Kiedy konieczne jest jawne podanie typu generycznego w useState?

  2. 2. Jak poprawnie typować useRef do przechowywania referencji do elementu input?

Zadania praktyczne w grze

  • Edytor kodu

    Typowanie useState z różnymi typami

  • Klikanie w kolejności

    Ułóż składnię rozszerzania interfejsu w TypeScript:

  • Edytor kodu

    Typowanie useRef dla elementów DOM i wartości

  • Układanie w pionie

    Ułóż kolejność kroków tworzenia typowanego stanu w React:

  • Układanie w poziomie

    Ułóż składnię useState z jawnym typem generycznym:

  1. Zadanie z kodemPraktyka: useState z typami
  2. Kliknij w kolejnościRozszerzanie interfejsów (extends)
  3. PytanieJawne typowanie useState
  4. PytanieTypowanie useRef dla elementu DOM
  5. Zadanie z kodemPraktyka: useRef z typami
  6. Ułóż w kolejnościKolejność typowania stanu komponentu
  7. Ułóż w kolejnościSkładnia useState z generykiem

Przydatne artykuły