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

Typowanie Zdarzeń - ChangeEvent, FormEvent, MouseEvent

5 min czytania ·
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. 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

  1. PytanieTyp zdarzenia zmiany wartości inputa
  2. Ułóż w kolejnościHierarchia typów zdarzeń React
  3. Zadanie z kodemPraktyka: Typowane zdarzenia w formularzu
  4. Kliknij w kolejnościTyp handlera zdarzenia kliknięcia
  5. Zadanie z kodemPraktyka: Zdarzenia klawiatury i myszy

Przydatne artykuły