Kurs JavaScript i React · Moduł 12: React i TypeScript
Typowanie Zdarzeń - ChangeEvent, FormEvent, MouseEvent
W tej lekcji6
Wydzielasz funkcję obsługi kliknięcia poza JSX, piszesz (event) => ... i nagle edytor nie wie nic o event: ani że ma pole value, ani że da się wywołać preventDefault(). Zdarzenia w React to sygnały z różnych części statku kosmicznego - kliknięcia przycisków, wprowadzanie danych, przesyłanie formularzy. TypeScript pozwala precyzyjnie określić, jaki sygnał otrzymujesz i z jakiego źródła.
Dobra wiadomość na start: gdy piszesz funkcję bezpośrednio w atrybucie, na przykład onChange={e => ...}, TypeScript sam wydedukuje typ zdarzenia. Jawny typ jest potrzebny dopiero wtedy, gdy handler to osobna funkcja - a tak robi się w większości prawdziwych komponentów.
Podstawowe typy zdarzeń
React dostarcza własne typy zdarzeń, które są generyczne - w nawiasach ostrych podajesz, z jakiego elementu HTML pochodzi zdarzenie. Wszystkie wywodzą się z bazowego typu React.SyntheticEvent, czyli opakowania, którym React otacza natywne zdarzenie przeglądarki. Najczęstsze to MouseEvent (mysz), ChangeEvent (zmiana wartości pola) i SubmitEvent (wysłanie formularza):
import React from 'react';
// Zdarzenie kliknięcia
const handleClick = (event: React.MouseEvent<HTMLButtonElement>) => {
console.log("Kliknięto przycisk:", event.currentTarget.textContent);
};
// Zdarzenie zmiany wartości
const handleChange = (event: React.ChangeEvent<HTMLInputElement>) => {
console.log("Nowa wartość:", event.target.value);
};
// Zdarzenie przesłania formularza
const handleSubmit = (event: React.SubmitEvent<HTMLFormElement>) => {
event.preventDefault();
console.log("Formularz przesłany!");
};Parametr w nawiasach ostrych to element, do którego podpięto handler. Dzięki niemu event.currentTarget w pierwszym handlerze ma typ HTMLButtonElement, a event.target.value w drugim jest tekstem. Metoda preventDefault() zatrzymuje domyślne przeładowanie strony po wysłaniu formularza.
FormEvent - starsza nazwa
Przez lata formularze typowano jako React.FormEvent i tak wygląda ogromna część istniejącego kodu, a także tytuł tej lekcji. Od @types/react 19.2.10 (styczeń 2026) FormEvent jest oznaczony jako przestarzały (deprecated), bo nie odpowiada żadnemu prawdziwemu zdarzeniu przeglądarki. Zamiast niego używaj SubmitEvent dla onSubmit, ChangeEvent dla onChange albo ogólnego SyntheticEvent.
// Starszy zapis - nadal się kompiluje, ale jest deprecated
const handleSubmitLegacy = (event: React.FormEvent<HTMLFormElement>) => {
event.preventDefault();
};Ten kod wciąż działa i przejdzie kompilację, edytor jedynie przekreśli nazwę typu. Jeśli Twój projekt ma starsze typy niż 19.2.10, SubmitEvent nie będzie jeszcze dostępny - wtedy zostań przy FormEvent i zaktualizuj pakiet przy najbliższej okazji.
ChangeEvent - różne elementy formularzy
Typ ChangeEvent różni się w zależności od elementu, na którym nasłuchujesz. Pole tekstowe, pole wieloliniowe i lista rozwijana mają value typu string, a checkbox dodatkowo checked typu boolean:
// Input tekstowy
const handleTextChange = (e: React.ChangeEvent<HTMLInputElement>) => {
const value: string = e.target.value;
const name: string = e.target.name;
};
// Textarea
const handleTextareaChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
const value: string = e.target.value;
};
// Select
const handleSelectChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
const selectedValue: string = e.target.value;
};
// Checkbox
const handleCheckboxChange = (e: React.ChangeEvent<HTMLInputElement>) => {
const isChecked: boolean = e.target.checked;
};Zwróć uwagę, że checkbox to też HTMLInputElement - zmienia się tylko pole, które odczytujesz. Uwaga: value jest zawsze tekstem, nawet w <input type="number">. Liczbę uzyskasz przez Number(e.target.value) albo e.target.valueAsNumber.
MouseEvent - kliknięcia i ruch myszy
MouseEvent niesie współrzędne kursora (clientX, clientY) i informację o elemencie. Ten sam typ obsługuje kliknięcie oraz najechanie myszą:
// Kliknięcie przycisku
const handleButtonClick = (e: React.MouseEvent<HTMLButtonElement>) => {
console.log("Pozycja kliknięcia:", e.clientX, e.clientY);
};
// Kliknięcie na div
const handleDivClick = (e: React.MouseEvent<HTMLDivElement>) => {
const target = e.currentTarget; // HTMLDivElement
};
// Najechanie myszą
const handleMouseEnter = (e: React.MouseEvent<HTMLDivElement>) => {
console.log("Mysz najechała na element");
};currentTarget to zawsze element z handlerem, dlatego ma precyzyjny typ. target przy kliknięciu może być dowolnym dzieckiem wewnątrz, więc TypeScript typuje go ogólnie.
KeyboardEvent - zdarzenia klawiatury
Dla klawiatury używasz KeyboardEvent, a naciśnięty klawisz odczytasz z pola key:
const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
if (e.key === "Enter") {
console.log("Enter naciśnięty!");
}
if (e.key === "Escape") {
console.log("Escape naciśnięty!");
}
};Pole key zawiera czytelną nazwę klawisza, na przykład "Enter" lub "a". Starsze pole keyCode jest przestarzałe, więc nie używaj go w nowym kodzie.
Praktyczny przykład - formularz z typowaniem
Złóżmy wszystko w formularz planowania misji. Najpierw typ danych formularza, potem stan otypowany generykiem, jak w poprzedniej lekcji:
interface MissionFormData {
name: string;
destination: string;
crewSize: number;
priority: "low" | "medium" | "high";
}
function MissionForm() {
const [formData, setFormData] = useState<MissionFormData>({
name: "",
destination: "",
crewSize: 1,
priority: "medium"
});Teraz trzy handlery. Zapis [name]: value ustawia pole o nazwie pobranej z atrybutu name pola. Słowo as to asercja typu: mówimy kompilatorowi, że tekst z listy na pewno jest jednym z trzech priorytetów, bo sami zdefiniowaliśmy opcje. Używaj as oszczędnie - wyłącza sprawdzanie w tym miejscu.
const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
const { name, value } = e.target;
setFormData(prev => ({ ...prev, [name]: value }));
};
const handleSelectChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
setFormData(prev => ({
...prev,
priority: e.target.value as MissionFormData["priority"]
}));
};
const handleSubmit = (e: React.SubmitEvent<HTMLFormElement>) => {
e.preventDefault();
console.log("Misja zaplanowana:", formData);
};Na koniec JSX, w którym podpinamy handlery. Typ elementu w każdym handlerze musi zgadzać się z elementem w JSX - handler dla select nie zostanie przyjęty przez input.
return (
<form onSubmit={handleSubmit}>
<input name="name" value={formData.name} onChange={handleInputChange} />
<input name="destination" value={formData.destination} onChange={handleInputChange} />
<select value={formData.priority} onChange={handleSelectChange}>
<option value="low">Niski</option>
<option value="medium">Średni</option>
<option value="high">Wysoki</option>
</select>
<button type="submit">Zaplanuj misję</button>
</form>
);
}Formularz działa jak zwykły formularz React - typy nie dodały ani jednego atrybutu w JSX, za to każdy handler jest teraz sprawdzany przez kompilator.
Funkcje jako props - typowanie callbacków
Gdy komponent przyjmuje handler od rodzica, typ funkcji zapisujesz w interfejsie props. void oznacza, że wynik funkcji nas nie interesuje:
interface ActionButtonProps {
label: string;
onClick: (e: React.MouseEvent<HTMLButtonElement>) => void;
onHover?: (e: React.MouseEvent<HTMLButtonElement>) => void;
}
function ActionButton({ label, onClick, onHover }: ActionButtonProps) {
return (
<button onClick={onClick} onMouseEnter={onHover}>
{label}
</button>
);
}Moja rada: nie zgaduj typu zdarzenia - najedź kursorem na atrybut onChange w edytorze, a TypeScript pokaże dokładny typ do skopiowania. W lekcji o komponentach generycznych wykorzystasz te handlery w uniwersalnym polu wyboru.
Kod do tej lekcji: App.tsx
import React, { useState } from 'react';
// Interfejs danych formularza misji
interface MissionFormData {
name: string;
destination: string;
crewSize: number;
priority: "low" | "medium" | "high";
notes: string;
}
// Interfejs misji (z id i datą)
interface Mission extends MissionFormData {
id: number;
createdAt: string;
}
function App() {
const [missions, setMissions] = useState<Mission[]>([]);
const [formData, setFormData] = useState<MissionFormData>({
name: "",
destination: "",
crewSize: 1,
priority: "medium",
notes: ""
});
// Typowane zdarzenia formularza
const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
const { name, value, type } = e.target;
setFormData(prev => ({
...prev,
[name]: type === "number" ? Number(value) : value
}));
};
const handleTextareaChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
setFormData(prev => ({ ...prev, notes: e.target.value }));
};
const handleSelectChange = (e: React.ChangeEvent<HTMLSelectElement>) => {
setFormData(prev => ({
...prev,
priority: e.target.value as MissionFormData["priority"]
}));
};
const handleSubmit = (e: React.FormEvent<HTMLFormElement>) => {
e.preventDefault();
const newMission: Mission = {
...formData,
id: Date.now(),
createdAt: new Date().toLocaleString()
};
setMissions(prev => [...prev, newMission]);
setFormData({ name: "", destination: "", crewSize: 1, priority: "medium", notes: "" });
};
const handleDelete = (e: React.MouseEvent<HTMLButtonElement>, id: number) => {
e.stopPropagation();
setMissions(prev => prev.filter(m => m.id !== id));
};
const priorityColors = { low: "#22c55e", medium: "#f59e0b", high: "#ef4444" };
return (
<div className="app">
<h1>Planowanie Misji Kosmicznych</h1>
<form onSubmit={handleSubmit} className="form">
<input name="name" value={formData.name} onChange={handleInputChange}
placeholder="Nazwa misji" required />
<input name="destination" value={formData.destination} onChange={handleInputChange}
placeholder="Cel misji" required />
<input name="crewSize" type="number" min={1} max={20}
value={formData.crewSize} onChange={handleInputChange} />
<select value={formData.priority} onChange={handleSelectChange}>
<option value="low">Niski priorytet</option>
<option value="medium">Sredni priorytet</option>
<option value="high">Wysoki priorytet</option>
</select>
<textarea value={formData.notes} onChange={handleTextareaChange}
placeholder="Notatki..." rows={2} />
<button type="submit">Zaplanuj misje</button>
</form>
<div className="missions">
{missions.map(mission => (
<div key={mission.id} className="mission-card">
<h3>{mission.name}</h3>
<p>Cel: {mission.destination}</p>
<p>Zaloga: {mission.crewSize} os.</p>
<span className="priority" style={{ color: priorityColors[mission.priority] }}>
{mission.priority.toUpperCase()}
</span>
{mission.notes && <p className="notes">{mission.notes}</p>}
<p className="date">{mission.createdAt}</p>
<button className="delete" onClick={(e) => handleDelete(e, mission.id)}>Usun</button>
</div>
))}
{missions.length === 0 && <p className="empty">Brak zaplanowanych misji</p>}
</div>
</div>
);
}
export default App;Pamiętaj: typ zdarzenia mówi, z którego pulpitu statku przyszedł sygnał - znając źródło, wiesz, jakie dane niesie.
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. Jaki typ zdarzenia należy użyć w handlerze onChange dla elementu <input>?
Zadania praktyczne w grze
- Układanie w pionie
Ułóż typy zdarzeń od najbardziej ogólnego do najbardziej specyficznego:
- Edytor kodu
Typowanie zdarzeń onChange i onSubmit
- Klikanie w kolejności
Ułóż sygnaturę typowanego handlera kliknięcia przycisku:
- Edytor kodu
Typowanie zdarzeń myszy i klawiatury