Kurs JavaScript i React · Moduł 3: Stan i zdarzenia

Formularze w React - kontrolowane komponenty

6 min czytania ·
W tej lekcji6

Na pokładzie statku kosmicznego React formularze to jak panele konfiguracyjne - służą do wprowadzania danych nawigacyjnych, ustawiania parametrów misji i komunikacji z centrum dowodzenia. W tej lekcji poznasz kontrolowane komponenty - wzorzec, w którym React przejmuje pełną kontrolę nad danymi formularza, tak jak komputer pokładowy kontroluje każdy system statku.

Kontrolowane vs niekontrolowane komponenty

W React wyróżniamy dwa podejścia do obsługi formularzy:

Kontrolowane komponenty - React zarządza wartością inputa poprzez state. Każda zmiana przechodzi przez useState i onChange:

function ControlledInput() {
  const [name, setName] = useState("");

  return (
    <input
      type="text"
      value={name}
      onChange={(e) => setName(e.target.value)}
    />
  );
}

Niekontrolowane komponenty - przeglądarka zarządza wartością, a my odczytujemy ją przez ref:

function UncontrolledInput() {
  const inputRef = useRef(null);

  const handleSubmit = (e) => {
    e.preventDefault();
    console.log(inputRef.current.value);
  };

  return (
    <form onSubmit={handleSubmit}>
      <input type="text" ref={inputRef} />
      <button type="submit">Wyślij</button>
    </form>
  );
}

Dlaczego kontrolowane komponenty są lepsze? Tak jak komputer pokładowy statku musi znać stan każdego systemu w każdej chwili, kontrolowane komponenty dają Reactowi pełny wgląd w dane formularza. Dzięki temu możesz walidować, formatować i reagować na zmiany w czasie rzeczywistym.

Obsługa pól tekstowych z useState

Prosty input tekstowy

function PilotRegistration() {
  const [pilotName, setPilotName] = useState("");
  const [callSign, setCallSign] = useState("");

  return (
    <div className="registration-form">
      <h2>Rejestracja pilota</h2>

      <label>Imię pilota:</label>
      <input
        type="text"
        value={pilotName}
        onChange={(e) => setPilotName(e.target.value)}
        placeholder="Wpisz imię..."
      />

      <label>Znak wywoławczy:</label>
      <input
        type="text"
        value={callSign}
        onChange={(e) => setCallSign(e.target.value.toUpperCase())}
        placeholder="Np. ALPHA-7"
      />

      <p>Pilot: {pilotName} ({callSign})</p>
    </div>
  );
}

Zarządzanie wieloma polami jednym stanem

Zamiast tworzyć osobny useState dla każdego pola, możesz użyć jednego obiektu stanu - jak centralny rejestr danych misji:

function MissionConfigForm() {
  const [formData, setFormData] = useState({
    missionName: "",
    destination: "",
    crewSize: "",
    priority: "normal"
  });

  const handleChange = (event) => {
    const { name, value } = event.target;
    setFormData((prev) => ({
      ...prev,
      [name]: value
    }));
  };

  return (
    <div className="mission-config">
      <h2>Konfiguracja misji</h2>

      <label>Nazwa misji:</label>
      <input
        type="text"
        name="missionName"
        value={formData.missionName}
        onChange={handleChange}
      />

      <label>Cel podróży:</label>
      <input
        type="text"
        name="destination"
        value={formData.destination}
        onChange={handleChange}
      />

      <label>Rozmiar załogi:</label>
      <input
        type="number"
        name="crewSize"
        value={formData.crewSize}
        onChange={handleChange}
      />

      <label>Priorytet:</label>
      <input
        type="text"
        name="priority"
        value={formData.priority}
        onChange={handleChange}
      />

      <pre>{JSON.stringify(formData, null, 2)}</pre>
    </div>
  );
}

Kluczowa sztuczka: atrybut name na inputach odpowiada kluczom w obiekcie stanu, a [name]: value (computed property name) dynamicznie aktualizuje odpowiednie pole.

Checkboxy i elementy select

Checkbox - przełączniki systemów

Checkboxy w React używają checked zamiast value:

function ShipSystemsPanel() {
  const [systems, setSystems] = useState({
    engines: true,
    shields: false,
    weapons: false,
    lifeSupport: true
  });

  const handleToggle = (event) => {
    const { name, checked } = event.target;
    setSystems((prev) => ({
      ...prev,
      [name]: checked
    }));
  };

  return (
    <div className="systems-panel">
      <h2>Systemy statku</h2>

      <label>
        <input
          type="checkbox"
          name="engines"
          checked={systems.engines}
          onChange={handleToggle}
        />
        Silniki
      </label>

      <label>
        <input
          type="checkbox"
          name="shields"
          checked={systems.shields}
          onChange={handleToggle}
        />
        Tarcze ochronne
      </label>

      <label>
        <input
          type="checkbox"
          name="weapons"
          checked={systems.weapons}
          onChange={handleToggle}
        />
        Systemy uzbrojenia
      </label>

      <label>
        <input
          type="checkbox"
          name="lifeSupport"
          checked={systems.lifeSupport}
          onChange={handleToggle}
        />
        Podtrzymywanie życia
      </label>

      <div className="status">
        Aktywne systemy: {Object.entries(systems)
          .filter(([, active]) => active)
          .map(([name]) => name)
          .join(", ")}
      </div>
    </div>
  );
}

Select - wybór z listy

Element <select> w React działa jak inne kontrolowane inputy - wartość kontrolujemy przez value i onChange:

function NavigationPanel() {
  const [destination, setDestination] = useState("");
  const [warpSpeed, setWarpSpeed] = useState("1");

  const destinations = [
    { value: "mars", label: "Mars" },
    { value: "jupiter", label: "Jowisz" },
    { value: "saturn", label: "Saturn" },
    { value: "alpha-centauri", label: "Alfa Centauri" },
    { value: "andromeda", label: "Galaktyka Andromedy" }
  ];

  return (
    <div className="nav-panel">
      <h2>Panel nawigacji</h2>

      <label>Cel podróży:</label>
      <select
        value={destination}
        onChange={(e) => setDestination(e.target.value)}
      >
        <option value="">-- Wybierz cel --</option>
        {destinations.map((dest) => (
          <option key={dest.value} value={dest.value}>
            {dest.label}
          </option>
        ))}
      </select>

      <label>Prędkość warp:</label>
      <select
        value={warpSpeed}
        onChange={(e) => setWarpSpeed(e.target.value)}
      >
        <option value="1">Warp 1</option>
        <option value="3">Warp 3</option>
        <option value="5">Warp 5</option>
        <option value="9">Warp 9 (maksimum)</option>
      </select>

      {destination && (
        <p>Kurs ustawiony: {destination} z prędkością Warp {warpSpeed}</p>
      )}
    </div>
  );
}

Obsługa wysyłania formularza

Wysyłanie formularza to jak nadanie rozkazu z centrum dowodzenia - musi być kontrolowane i bezpieczne:

function MissionReportForm() {
  const [formData, setFormData] = useState({
    missionName: "",
    commander: "",
    status: "in-progress",
    description: "",
    isClassified: false
  });
  const [submitted, setSubmitted] = useState(false);

  const handleChange = (event) => {
    const { name, value, type, checked } = event.target;
    setFormData((prev) => ({
      ...prev,
      [name]: type === "checkbox" ? checked : value
    }));
  };

  const handleSubmit = (event) => {
    event.preventDefault();

    // Walidacja
    if (!formData.missionName.trim() || !formData.commander.trim()) {
      alert("Wypełnij wszystkie wymagane pola!");
      return;
    }

    console.log("Raport misji:", formData);
    setSubmitted(true);
  };

  const handleReset = () => {
    setFormData({
      missionName: "",
      commander: "",
      status: "in-progress",
      description: "",
      isClassified: false
    });
    setSubmitted(false);
  };

  if (submitted) {
    return (
      <div className="success">
        <h2>Raport wysłany!</h2>
        <p>Misja: {formData.missionName}</p>
        <button onClick={handleReset}>Nowy raport</button>
      </div>
    );
  }

  return (
    <form onSubmit={handleSubmit} className="mission-report">
      <h2>Raport misji</h2>

      <label>Nazwa misji *:</label>
      <input
        type="text"
        name="missionName"
        value={formData.missionName}
        onChange={handleChange}
        required
      />

      <label>Dowódca *:</label>
      <input
        type="text"
        name="commander"
        value={formData.commander}
        onChange={handleChange}
        required
      />

      <label>Status:</label>
      <select name="status" value={formData.status} onChange={handleChange}>
        <option value="in-progress">W trakcie</option>
        <option value="completed">Zakończona</option>
        <option value="failed">Niepowodzenie</option>
      </select>

      <label>Opis:</label>
      <textarea
        name="description"
        value={formData.description}
        onChange={handleChange}
        rows={4}
        placeholder="Opisz przebieg misji..."
      />

      <label>
        <input
          type="checkbox"
          name="isClassified"
          checked={formData.isClassified}
          onChange={handleChange}
        />
        Raport tajny
      </label>

      <div className="form-actions">
        <button type="submit">Wyślij raport</button>
        <button type="button" onClick={handleReset}>Wyczyść</button>
      </div>
    </form>
  );
}

Lifting state up - podnoszenie stanu

Kiedy kilka komponentów musi współdzielić dane formularza, przenosimy stan do ich wspólnego rodzica - jak centrala dowodzenia koordynująca dane z wielu paneli:

function TemperatureInput({ label, value, onChange }) {
  return (
    <div>
      <label>{label}:</label>
      <input
        type="number"
        value={value}
        onChange={(e) => onChange(e.target.value)}
      />
    </div>
  );
}

function TemperatureConverter() {
  // Rodzic pamięta tylko to, co wpisano ostatnio, i w której skali
  const [temperature, setTemperature] = useState({ scale: "c", value: "" });

  const convert = (value, formula) => {
    const number = parseFloat(value);
    return Number.isNaN(number) ? "" : String(Math.round(formula(number) * 100) / 100);
  };

  const celsius = temperature.scale === "f"
    ? convert(temperature.value, (f) => ((f - 32) * 5) / 9)
    : temperature.value;
  const fahrenheit = temperature.scale === "c"
    ? convert(temperature.value, (c) => (c * 9) / 5 + 32)
    : temperature.value;

  return (
    <div className="converter">
      <h2>Konwerter temperatury kadłuba</h2>
      <TemperatureInput
        label="Celsius"
        value={celsius}
        onChange={(value) => setTemperature({ scale: "c", value })}
      />
      <TemperatureInput
        label="Fahrenheit"
        value={fahrenheit}
        onChange={(value) => setTemperature({ scale: "f", value })}
      />
    </div>
  );
}

W tym wzorcu:

  • Stan (temperature: ostatnio wpisana wartość i jej skala) żyje w rodzicu (TemperatureConverter)
  • Komponenty dzieci (TemperatureInput) otrzymują wartość przez props
  • Zmiany przekazywane są w górę przez callback onChange
  • Rodzic przelicza i synchronizuje obie wartości

Rodzic nie zapisuje gotowych stopni Celsjusza, tylko ostatnio wpisaną wartość i jej skalę. Dzięki temu pole, w którym piszesz, pokazuje dokładnie to, co wpisujesz (także samo - albo 10), a drugie pole jest przeliczane i zaokrąglane do dwóch miejsc po przecinku.

Podsumowanie

Formularze w React - kluczowe zasady:

  1. Kontrolowane komponenty - React zarządza wartością inputów przez value + onChange
  2. Jeden state dla wielu pól - użyj obiektu stanu z dynamicznym [name]: value
  3. Checkboxy - używaj checked zamiast value, odczytuj event.target.checked
  4. Select - kontroluj przez value na <select>, nie na <option>
  5. preventDefault() - zawsze blokuj domyślne wysyłanie formularza
  6. Walidacja - sprawdzaj dane w handlerze onSubmit przed wysłaniem
  7. Lifting state up - przenieś stan do wspólnego rodzica, gdy komponenty muszą współdzielić dane
Kod do tej lekcji: App.jsx
import React, { useState } from 'react';

function SpaceMissionForm() {
  const [formData, setFormData] = useState({
    missionName: '',
    destination: 'mars',
    crewSize: 4,
    duration: '',
    priority: 'medium',
    equipment: [],
    notes: '',
    launchDate: '',
    isUrgent: false
  });

  const [errors, setErrors] = useState({});
  const [submitted, setSubmitted] = useState(false);

  const equipmentOptions = [
    { id: 'rover', label: 'Łazik' },
    { id: 'drone', label: 'Dron' },
    { id: 'satellite', label: 'Satelita' },
    { id: 'telescope', label: 'Teleskop' },
    { id: 'lab', label: 'Laboratorium' }
  ];

  const handleChange = (e) => {
    const { name, value, type, checked } = e.target;
    setFormData(prev => ({
      ...prev,
      [name]: type === 'checkbox' ? checked : value
    }));
    if (errors[name]) {
      setErrors(prev => ({ ...prev, [name]: null }));
    }
  };

  const handleEquipmentChange = (id) => {
    setFormData(prev => ({
      ...prev,
      equipment: prev.equipment.includes(id)
        ? prev.equipment.filter(e => e !== id)
        : [...prev.equipment, id]
    }));
  };

  const validate = () => {
    const newErrors = {};
    if (!formData.missionName.trim()) newErrors.missionName = 'Nazwa misji jest wymagana';
    if (!formData.duration || formData.duration < 1) newErrors.duration = 'Czas trwania musi być większy niż 0';
    if (!formData.launchDate) newErrors.launchDate = 'Data startu jest wymagana';
    if (formData.equipment.length === 0) newErrors.equipment = 'Wybierz przynajmniej jedno wyposażenie';
    return newErrors;
  };

  const handleSubmit = (e) => {
    e.preventDefault();
    const newErrors = validate();
    if (Object.keys(newErrors).length > 0) {
      setErrors(newErrors);
      return;
    }
    setSubmitted(true);
    console.log('Submitted:', formData);
  };

  const handleReset = () => {
    setFormData({
      missionName: '', destination: 'mars', crewSize: 4, duration: '',
      priority: 'medium', equipment: [], notes: '', launchDate: '', isUrgent: false
    });
    setErrors({});
    setSubmitted(false);
  };

  if (submitted) {
    return (
      <div style={{ fontFamily: 'Arial', padding: '40px', textAlign: 'center' }}>
        <div style={{ fontSize: '64px', marginBottom: '20px' }}>▲</div>
        <h1 style={{ color: '#4caf50' }}>Misja zaplanowana!</h1>
        <div style={{ backgroundColor: '#f5f5f5', padding: '20px', borderRadius: '12px', maxWidth: '500px', margin: '20px auto', textAlign: 'left' }}>
          <p><strong>Nazwa:</strong> {formData.missionName}</p>
          <p><strong>Cel:</strong> {formData.destination}</p>
          <p><strong>Załoga:</strong> {formData.crewSize} osób</p>
          <p><strong>Czas trwania:</strong> {formData.duration} dni</p>
          <p><strong>Data startu:</strong> {formData.launchDate}</p>
          <p><strong>Wyposażenie:</strong> {formData.equipment.join(', ')}</p>
        </div>
        <button onClick={handleReset} style={{ padding: '12px 24px', backgroundColor: '#667eea', color: 'white', border: 'none', borderRadius: '8px', cursor: 'pointer' }}>
          Zaplanuj nową misję
        </button>
      </div>
    );
  }

  return (
    <div style={{ fontFamily: 'Arial', padding: '20px', maxWidth: '600px', margin: '0 auto' }}>
      <h1 style={{ textAlign: 'center', color: '#667eea' }}>Planowanie Misji Kosmicznej</h1>

      <form onSubmit={handleSubmit} style={{ display: 'flex', flexDirection: 'column', gap: '20px' }}>
        <div>
          <label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Nazwa misji *</label>
          <input type="text" name="missionName" value={formData.missionName} onChange={handleChange}
            style={{ width: '100%', padding: '10px', borderRadius: '8px', border: errors.missionName ? '2px solid #f44336' : '1px solid #ddd', boxSizing: 'border-box' }}
          />
          {errors.missionName && <span style={{ color: '#f44336', fontSize: '12px' }}>{errors.missionName}</span>}
        </div>

        <div>
          <label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Cel podróży</label>
          <select name="destination" value={formData.destination} onChange={handleChange}
            style={{ width: '100%', padding: '10px', borderRadius: '8px', border: '1px solid #ddd' }}>
            <option value="mars">Mars</option>
            <option value="moon">Księżyc</option>
            <option value="venus">Wenus</option>
            <option value="jupiter">Jowisz</option>
            <option value="saturn">Saturn</option>
          </select>
        </div>

        <div>
          <label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Wielkość załogi: {formData.crewSize}</label>
          <input type="range" name="crewSize" min="1" max="20" value={formData.crewSize} onChange={handleChange}
            style={{ width: '100%' }}
          />
        </div>

        <div>
          <label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Czas trwania (dni) *</label>
          <input type="number" name="duration" value={formData.duration} onChange={handleChange}
            style={{ width: '100%', padding: '10px', borderRadius: '8px', border: errors.duration ? '2px solid #f44336' : '1px solid #ddd', boxSizing: 'border-box' }}
          />
          {errors.duration && <span style={{ color: '#f44336', fontSize: '12px' }}>{errors.duration}</span>}
        </div>

        <div>
          <label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Data startu *</label>
          <input type="date" name="launchDate" value={formData.launchDate} onChange={handleChange}
            style={{ width: '100%', padding: '10px', borderRadius: '8px', border: errors.launchDate ? '2px solid #f44336' : '1px solid #ddd', boxSizing: 'border-box' }}
          />
          {errors.launchDate && <span style={{ color: '#f44336', fontSize: '12px' }}>{errors.launchDate}</span>}
        </div>

        <div>
          <label style={{ display: 'block', marginBottom: '10px', fontWeight: 'bold' }}>Priorytet</label>
          <div style={{ display: 'flex', gap: '20px' }}>
            {['low', 'medium', 'high'].map(p => (
              <label key={p} style={{ display: 'flex', alignItems: 'center', gap: '5px' }}>
                <input type="radio" name="priority" value={p} checked={formData.priority === p} onChange={handleChange} />
                {p === 'low' ? 'Niski' : p === 'medium' ? 'Średni' : 'Wysoki'}
              </label>
            ))}
          </div>
        </div>

        <div>
          <label style={{ display: 'block', marginBottom: '10px', fontWeight: 'bold' }}>Wyposażenie *</label>
          <div style={{ display: 'flex', flexWrap: 'wrap', gap: '10px' }}>
            {equipmentOptions.map(eq => (
              <label key={eq.id} style={{
                padding: '8px 16px', borderRadius: '20px', cursor: 'pointer',
                backgroundColor: formData.equipment.includes(eq.id) ? '#667eea' : '#e0e0e0',
                color: formData.equipment.includes(eq.id) ? 'white' : '#333'
              }}>
                <input type="checkbox" checked={formData.equipment.includes(eq.id)}
                  onChange={() => handleEquipmentChange(eq.id)} style={{ display: 'none' }}
                />
                {eq.label}
              </label>
            ))}
          </div>
          {errors.equipment && <span style={{ color: '#f44336', fontSize: '12px' }}>{errors.equipment}</span>}
        </div>

        <div>
          <label style={{ display: 'flex', alignItems: 'center', gap: '10px', cursor: 'pointer' }}>
            <input type="checkbox" name="isUrgent" checked={formData.isUrgent} onChange={handleChange} />
            <span style={{ fontWeight: 'bold' }}>Misja pilna</span>
          </label>
        </div>

        <div>
          <label style={{ display: 'block', marginBottom: '5px', fontWeight: 'bold' }}>Notatki</label>
          <textarea name="notes" value={formData.notes} onChange={handleChange} rows="3"
            style={{ width: '100%', padding: '10px', borderRadius: '8px', border: '1px solid #ddd', boxSizing: 'border-box', resize: 'vertical' }}
          />
        </div>

        <div style={{ display: 'flex', gap: '10px' }}>
          <button type="submit" style={{ flex: 1, padding: '12px', backgroundColor: '#4caf50', color: 'white', border: 'none', borderRadius: '8px', cursor: 'pointer', fontWeight: 'bold' }}>
            Zaplanuj misję
          </button>
          <button type="button" onClick={handleReset} style={{ flex: 1, padding: '12px', backgroundColor: '#f44336', color: 'white', border: 'none', borderRadius: '8px', cursor: 'pointer', fontWeight: 'bold' }}>
            Wyczyść
          </button>
        </div>
      </form>
    </div>
  );
}

export default function App() {
  return <SpaceMissionForm />;
}

Pamiętaj: Kontrolowane komponenty to jak system sterowania statkiem - komputer pokładowy (React) wie o każdej zmianie w czasie rzeczywistym i może natychmiast zareagować!

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. Czy można używać wielu useState w jednym komponencie?

  2. 2. Jaka jest różnica między state a props?

To 2 z 9 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Klikanie w kolejności

    Zbuduj handler onSubmit zapobiegający przeładowaniu strony:

  • Układanie w pionie

    Ułóż etapy tworzenia kontrolowanego formularza w React:

  • Edytor kodu

    Stwórz komponent EmergencyAlert ze stanem message wyświetlanym w akapicie <p> i wyrenderuj go w App. Dodaj przycisk ALARM: onClick ustawia komunikat 'Alarm aktywowany!', a onMouseEnter komunikat 'Uwaga: kursor nad przyciskiem alarmu'. Dodaj też pole <input> z onKeyDown, które po wciśnięciu Enter (e.key === 'Enter') ustawia komunikat 'Alarm uruchomiony z klawiatury', a inne klawisze ignoruje.

  • Edytor kodu

    Stwórz rodzica ColonyControl ze stanem powerLevel (useState(50)) i dwoje dzieci bez własnego stanu: PowerPlant({ powerLevel, onPowerChange }) wyświetla poziom mocy i ma przyciski +10 i -10, które wywołują onPowerChange z nową wartością, oraz LifeSupport({ powerLevel }), który wyświetla 'Systemy podtrzymywania życia: aktywne', gdy powerLevel >= 30, a w przeciwnym razie 'ALARM: za mało mocy'. ColonyControl przekazuje obu dzieciom ten sam powerLevel. Wyrenderuj ColonyControl w App.

  • Edytor kodu

    Stwórz komponent ColonyDashboard z czterema osobnymi stanami useState: temperature (np. -20), pressure (np. 600), oxygen (np. 21) i power (np. 80), i wyrenderuj go w App. Wyświetl wszystkie cztery wartości, a dla każdej dodaj przycisk, który zmienia tylko ją (np. Ogrzej +5, Ciśnienie +10, Tlen +1, Zasilanie -10).

  • Klikanie w kolejności

    Zbuduj wyrażenie pobierające wartość z pola input w event handlerze:

  • Układanie w poziomie

    Ułóż składnię importu hooka useState z React:

  • Klikanie w kolejności

    Ułóż etapy obsługi zdarzenia:

  • Układanie w pionie

    Ułóż sposoby przechowywania stanu od najprostszego do najbardziej rozbudowanego, tak jak w lekcji o przepływie danych:

  • Układanie w pionie

    Ułóż, co się dzieje po wpisaniu jednego znaku w kontrolowane pole <input value={name} onChange={(e) => setName(e.target.value)} />:

  • Klikanie w kolejności

    Ułóż kroki aktualizacji stanu:

  • Układanie w poziomie

    Ułóż poprawny atrybut onChange dla kontrolowanego inputa:

  • Klikanie w kolejności

    Kliknij elementy w kolejności tworzenia kontrolowanego inputa z onChange:

  • Układanie w pionie

    Ułóż kroki cyklu aktualizacji stanu w React od zdarzenia do aktualizacji DOM:

  • Układanie w poziomie

    Ułóż poprawną aktualizację jednej właściwości obiektu w useState:

  • Układanie w pionie

    Ułóż kroki walidacji w formularzu MissionPlanner z lekcji o obsłudze zdarzeń:

  1. Kliknij w kolejnościHandler onSubmit z preventDefault
  2. PytanieWiele zmiennych stanu
  3. Ułóż w kolejnościEtapy budowy kontrolowanego formularza
  4. Zadanie z kodemPraktyka: Zdarzenia onClick, onMouseEnter i onKeyDown
  5. PytanieState vs Props
  6. Zadanie z kodemPraktyka: Lifting state up
  7. PytaniePodnoszenie stanu
  8. Zadanie z kodemPraktyka: Wiele stanów
  9. PytanieEvent handler onClick
  10. Kliknij w kolejnościDostęp do wartości input przez event
  11. PytanieKontrolowane vs niekontrolowane komponenty
  12. Ułóż w kolejnościImport hooka useState
  13. Kliknij w kolejnościSortowanie: Przepływ obsługi zdarzeń
  14. Ułóż w kolejnościWzorce zarządzania stanem
  15. Ułóż w kolejnościCykl kontrolowanego pola formularza
  16. Kliknij w kolejnościSortowanie: proces aktualizacji stanu
  17. PytanieAsynchroniczna aktualizacja stanu
  18. Ułóż w kolejnościSkładnia onChange dla kontrolowanego inputa
  19. PytanieZalety kontrolowanych komponentów
  20. PytanieInicjalizacja useState
  21. PytanieWzorzec lifting state up
  22. Kliknij w kolejnościSkładnia kontrolowanego inputa
  23. Ułóż w kolejnościCykl aktualizacji stanu w React
  24. Ułóż w kolejnościAktualizacja obiektu operatorem spread
  25. Ułóż w kolejnościWalidacja formularza krok po kroku

Przydatne artykuły