Kurs JavaScript i React · Moduł 16: Obsługa błędów i Suspense
Obsługa błędów w formularzach
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ć:
- Konkretne -- "Hasło musi mieć min. 8 znaków" zamiast "Nieprawidłowe hasło"
- Pomocne -- powiedz użytkownikowi JAK naprawić błąd
- Widoczne -- wyświetlaj błąd blisko pola, którego dotyczy
- Delikatne -- nie wyświetlaj wszystkich błędów na raz przed pierwszym submit
- Dostępne -- używaj atrybutów
aria-invalidiaria-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. Jaka jest główna zaleta walidacji formularzy po stronie klienta (client-side)?
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: