Kurs JavaScript i React · Moduł 16: Obsługa błędów i Suspense

Obsługa błędów w formularzach

5 min czytania ·
W tej lekcji5

Wyobraź sobie, że twoja stacja kosmiczna ma panel rejestracji nowych członków załogi. Każde pole formularza to jak czujnik na statku -- jeśli dane są niepoprawne, system musi natychmiast powiadomić operatora zanim sekwencja startowa zostanie uruchomiona. Obsługa błędów w formularzach to kluczowy element UX każdej aplikacji React.

Wzorce walidacji formularzy

W React możemy wyróżnić dwa główne podejścia do walidacji formularzy:

1. Walidacja po stronie klienta (client-side)

Walidacja wykonywana w przeglądarce, zanim dane zostaną wysłane na serwer. Jest szybka i daje natychmiastowy feedback.

function RegistrationForm() {
  const [email, setEmail] = useState('');
  const [errors, setErrors] = useState({});

  const validateEmail = (value) => {
    if (!value) return 'Email jest wymagany';
    if (!value.includes('@')) return 'Nieprawidłowy format email';
    return null;
  };

  const handleChange = (e) => {
    const value = e.target.value;
    setEmail(value);
    const error = validateEmail(value);
    setErrors(prev => ({ ...prev, email: error }));
  };

  return (
    <div>
      <input value={email} onChange={handleChange} />
      {errors.email && <p className="error">{errors.email}</p>}
    </div>
  );
}

2. Walidacja po stronie serwera (server-side)

Serwer sprawdza dane po wysłaniu formularza i zwraca błędy. Jest niezbędna dla bezpieczeństwa -- walidacja kliencka może zostać pominięta.

const handleSubmit = async (formData) => {
  try {
    const response = await fetch('/api/register', {
      method: 'POST',
      body: JSON.stringify(formData),
    });
    const result = await response.json();

    if (!response.ok) {
      // Serwer zwrócił błędy walidacji
      setErrors(result.errors);
    }
  } catch (error) {
    setErrors({ general: 'Błąd połączenia z serwerem' });
  }
};

Wyświetlanie błędów na poziomie pól (field-level errors)

Każde pole formularza powinno mieć swój własny komunikat błędu, wyświetlany bezpośrednio pod polem. To jak indywidualne alarmy dla każdego systemu na statku kosmicznym.

function CrewRegistration() {
  const [formData, setFormData] = useState({
    name: '', callsign: '', rank: ''
  });
  const [errors, setErrors] = useState({});
  const [touched, setTouched] = useState({});

  const validate = (field, value) => {
    switch (field) {
      case 'name':
        if (!value.trim()) return 'Imię jest wymagane';
        if (value.length < 2) return 'Imię musi mieć min. 2 znaki';
        return null;
      case 'callsign':
        if (!value.trim()) return 'Znak wywoławczy jest wymagany';
        if (!/^[A-Z0-9-]+$/.test(value)) return 'Tylko wielkie litery, cyfry i myślniki';
        return null;
      case 'rank':
        if (!value) return 'Wybierz rangę';
        return null;
      default:
        return null;
    }
  };

  const handleBlur = (field) => {
    setTouched(prev => ({ ...prev, [field]: true }));
    const error = validate(field, formData[field]);
    setErrors(prev => ({ ...prev, [field]: error }));
  };

  const handleChange = (field, value) => {
    setFormData(prev => ({ ...prev, [field]: value }));
    // Waliduj tylko jeżeli pole było już dotykane
    if (touched[field]) {
      const error = validate(field, value);
      setErrors(prev => ({ ...prev, [field]: error }));
    }
  };

  return (
    <form>
      <div>
        <label>Imię</label>
        <input
          value={formData.name}
          onChange={(e) => handleChange('name', e.target.value)}
          onBlur={() => handleBlur('name')}
          className={errors.name ? 'input-error' : ''}
        />
        {touched.name && errors.name && (
          <p className="field-error">{errors.name}</p>
        )}
      </div>
      {/* Analogicznie dla pozostałych pól */}
    </form>
  );
}

Zwróć uwagę na wzorzec touched -- błędy wyświetlamy dopiero po tym, jak użytkownik opuścił pole (onBlur). Nie chcemy straszyć pilota alarmami zanim jeszcze skończył wpisywać dane!

Obsługa błędów serwera w formularzach

Serwer może zwrócić błędy, których nie da się przewidzieć po stronie klienta -- np. "ten email jest już zajęty" albo "przekroczono limit rejestracji".

function SubmitWithServerErrors() {
  const [errors, setErrors] = useState({});
  const [serverError, setServerError] = useState(null);

  const handleSubmit = async (e) => {
    e.preventDefault();
    setServerError(null);

    try {
      const response = await fetch('/api/crew/register', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(formData),
      });

      const data = await response.json();

      if (!response.ok) {
        if (data.fieldErrors) {
          // Błędy konkretnych pól (np. "email już istnieje")
          setErrors(data.fieldErrors);
        }
        if (data.message) {
          // Ogólny błąd serwera
          setServerError(data.message);
        }
        return;
      }

      // Sukces - przekierowanie lub komunikat
    } catch (error) {
      setServerError('Nie udało się połączyć ze stacją bazową');
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      {serverError && (
        <div className="server-error-banner">{serverError}</div>
      )}
      {/* Pola formularza z field-level errors */}
    </form>
  );
}

try-catch w handleSubmit

Każdy handler wysyłania formularza powinien być opakowany w try-catch. Bez tego błąd sieciowy lub nieoczekiwany błąd serwera spowoduje nieobsłużony wyjątek.

const handleSubmit = async (e) => {
  e.preventDefault();
  setIsSubmitting(true);
  setErrors({});

  try {
    // 1. Walidacja lokalna
    const validationErrors = validateAllFields(formData);
    if (Object.keys(validationErrors).length > 0) {
      setErrors(validationErrors);
      return;
    }

    // 2. Wysłanie do serwera
    const response = await submitToServer(formData);

    // 3. Obsługa odpowiedzi serwera
    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(errorData.message || 'Błąd serwera');
    }

    // 4. Sukces
    setSuccess(true);
  } catch (error) {
    // 5. Obsługa błędów
    setErrors({ submit: error.message });
  } finally {
    // 6. Zawsze wykonane - wyłącz loader
    setIsSubmitting(false);
  }
};

UX best practices dla komunikatów błędów

Dobre komunikaty błędów w formularzach powinny być:

  1. Konkretne -- "Hasło musi mieć min. 8 znaków" zamiast "Nieprawidłowe hasło"
  2. Pomocne -- powiedz użytkownikowi JAK naprawić błąd
  3. Widoczne -- wyświetlaj błąd blisko pola, którego dotyczy
  4. Delikatne -- nie wyświetlaj wszystkich błędów na raz przed pierwszym submit
  5. Dostępne -- używaj atrybutów aria-invalid i aria-describedby
<div className="form-field">
  <label htmlFor="password">Hasło</label>
  <input
    id="password"
    type="password"
    aria-invalid={!!errors.password}
    aria-describedby={errors.password ? 'password-error' : undefined}
  />
  {errors.password && (
    <p id="password-error" className="field-error" role="alert">
      {errors.password}
    </p>
  )}
</div>

Pamiętaj -- formularz to jak panel sterowania statku kosmicznego. Każdy błąd musi być komunikowany jasno i precyzyjnie, aby pilot (użytkownik) wiedział dokładnie, co poprawić. Nigdy nie pokazuj tajemniczych kodów błędów -- zawsze tłumacz je na język zrozumiały dla człowieka.

Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
import './styles.css';

// Formularz rejestracji czlonka zalogi z walidacja
function CrewRegistrationForm() {
  const [formData, setFormData] = useState({
    name: '', callsign: '', email: '', rank: ''
  });
  const [errors, setErrors] = useState({});
  const [touched, setTouched] = useState({});
  const [serverError, setServerError] = useState(null);
  const [isSubmitting, setIsSubmitting] = useState(false);
  const [success, setSuccess] = useState(false);

  const validate = (field, value) => {
    switch (field) {
      case 'name':
        if (!value.trim()) return 'Imie jest wymagane';
        if (value.length < 2) return 'Imie musi miec min. 2 znaki';
        return null;
      case 'callsign':
        if (!value.trim()) return 'Znak wywolawczy jest wymagany';
        if (!/^[A-Za-z0-9-]+$/.test(value))
          return 'Tylko litery, cyfry i myslniki';
        return null;
      case 'email':
        if (!value.trim()) return 'Email jest wymagany';
        if (!value.includes('@')) return 'Nieprawidlowy format email';
        return null;
      case 'rank':
        if (!value) return 'Wybierz range';
        return null;
      default:
        return null;
    }
  };

  const handleChange = (field, value) => {
    setFormData(prev => ({ ...prev, [field]: value }));
    if (touched[field]) {
      const error = validate(field, value);
      setErrors(prev => ({ ...prev, [field]: error }));
    }
  };

  const handleBlur = (field) => {
    setTouched(prev => ({ ...prev, [field]: true }));
    const error = validate(field, formData[field]);
    setErrors(prev => ({ ...prev, [field]: error }));
  };

  const handleSubmit = async (e) => {
    e.preventDefault();
    setServerError(null);
    setIsSubmitting(true);

    // Walidacja wszystkich pol
    const allErrors = {};
    const allTouched = {};
    for (const field of Object.keys(formData)) {
      allTouched[field] = true;
      const error = validate(field, formData[field]);
      if (error) allErrors[field] = error;
    }
    setTouched(allTouched);
    setErrors(allErrors);

    if (Object.keys(allErrors).length > 0) {
      setIsSubmitting(false);
      return;
    }

    try {
      // Symulacja wyslania do serwera
      await new Promise(resolve => setTimeout(resolve, 1000));

      // Symulacja bledu serwera (50% szans)
      if (Math.random() > 0.5) {
        throw new Error('Serwer odrzucil rejestracje: callsign juz istnieje');
      }

      setSuccess(true);
    } catch (error) {
      setServerError(error.message);
    } finally {
      setIsSubmitting(false);
    }
  };

  if (success) {
    return (
      <div className="success-panel">
        <h2>Rejestracja udana!</h2>
        <p>Witamy na pokladzie, {formData.callsign}!</p>
        <button onClick={() => { setSuccess(false); setFormData({ name: '', callsign: '', email: '', rank: '' }); setTouched({}); }}>
          Zarejestruj kolejnego
        </button>
      </div>
    );
  }

  return (
    <form onSubmit={handleSubmit} className="form">
      {serverError && (
        <div className="server-error">{serverError}</div>
      )}

      <div className="field">
        <label>Imie</label>
        <input
          value={formData.name}
          onChange={(e) => handleChange('name', e.target.value)}
          onBlur={() => handleBlur('name')}
          className={touched.name && errors.name ? 'input-error' : ''}
          placeholder="Np. Jan Kowalski"
        />
        {touched.name && errors.name && (
          <p className="field-error">{errors.name}</p>
        )}
      </div>

      <div className="field">
        <label>Znak wywolawczy</label>
        <input
          value={formData.callsign}
          onChange={(e) => handleChange('callsign', e.target.value)}
          onBlur={() => handleBlur('callsign')}
          className={touched.callsign && errors.callsign ? 'input-error' : ''}
          placeholder="Np. NOVA-7"
        />
        {touched.callsign && errors.callsign && (
          <p className="field-error">{errors.callsign}</p>
        )}
      </div>

      <div className="field">
        <label>Email</label>
        <input
          value={formData.email}
          onChange={(e) => handleChange('email', e.target.value)}
          onBlur={() => handleBlur('email')}
          className={touched.email && errors.email ? 'input-error' : ''}
          placeholder="Np. jan@stacja.kosmos"
        />
        {touched.email && errors.email && (
          <p className="field-error">{errors.email}</p>
        )}
      </div>

      <div className="field">
        <label>Ranga</label>
        <select
          value={formData.rank}
          onChange={(e) => handleChange('rank', e.target.value)}
          onBlur={() => handleBlur('rank')}
          className={touched.rank && errors.rank ? 'input-error' : ''}
        >
          <option value="">-- Wybierz range --</option>
          <option value="cadet">Kadet</option>
          <option value="officer">Oficer</option>
          <option value="commander">Komandor</option>
        </select>
        {touched.rank && errors.rank && (
          <p className="field-error">{errors.rank}</p>
        )}
      </div>

      <button type="submit" className="submit-btn" disabled={isSubmitting}>
        {isSubmitting ? 'Wysylanie...' : 'Zarejestruj czlonka zalogi'}
      </button>
    </form>
  );
}

export default function App() {
  return (
    <div className="app">
      <h1>Rejestracja Zalogi</h1>
      <p className="subtitle">Walidacja formularza z obsluga bledow</p>
      <CrewRegistrationForm />
    </div>
  );
}

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. Jaka jest główna zaleta walidacji formularzy po stronie klienta (client-side)?

  2. 2. Po co używamy wzorca touched (onBlur) przy wyświetlaniu błędów walidacji?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Kliknij elementy w kolejności kroków handleSubmit formularza:

  • Edytor kodu

    Zaimplementuj formularz z walidacją i obsługą błędów

  • Układanie w poziomie

    Ułóż poprawną składnię warunkowego wyświetlania błędu pola:

  • Układanie w pionie

    Uporządkuj typy błędów formularza od obsługiwanych najwcześniej do najpóźniej:

  1. PytanieWalidacja po stronie klienta
  2. PytanieWzorzec touched w formularzach
  3. Kliknij w kolejnościKroki handleSubmit z try-catch
  4. Zadanie z kodemPraktyka: Walidacja formularza
  5. Ułóż w kolejnościWyświetlanie błędu pola formularza
  6. Ułóż w kolejnościTypy błędów formularza

Przydatne artykuły