Kurs JavaScript i React · Moduł 12: React i TypeScript
Typowanie useState i useRef
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); // booleanTypeScript 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. Kiedy konieczne jest jawne podanie typu generycznego w useState?
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:
Zadania po tej lekcji
- Zadanie z kodemPraktyka: useState z typami
- Kliknij w kolejnościRozszerzanie interfejsów (extends)
- PytanieJawne typowanie useState
- PytanieTypowanie useRef dla elementu DOM
- Zadanie z kodemPraktyka: useRef z typami
- Ułóż w kolejnościKolejność typowania stanu komponentu
- Ułóż w kolejnościSkładnia useState z generykiem