JavaScript and React course ยท Module 16: Error Handling and Suspense
Error Handling in Forms
In this lesson5
Imagine your space station has a crew registration panel. Each form field is like a sensor on the ship -- if the data is incorrect, the system must immediately notify the operator before the launch sequence is initiated. Error handling in forms is a key UX element of every React application.
Form Validation Patterns
In React, we can distinguish two main approaches to form validation:
1. Client-side Validation
Validation performed in the browser before data is sent to the server. It's fast and provides immediate feedback.
function RegistrationForm() {
const [email, setEmail] = useState('');
const [errors, setErrors] = useState({});
const validateEmail = (value) => {
if (!value) return 'Email is required';
if (!value.includes('@')) return 'Invalid email format';
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. Server-side Validation
The server validates the data after the form is submitted and returns errors. It's essential for security -- client-side validation can be bypassed.
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) {
// Server returned validation errors
setErrors(result.errors);
}
} catch (error) {
setErrors({ general: 'Connection error with server' });
}
};Displaying Field-Level Errors
Each form field should have its own error message, displayed directly below the field. It's like individual alarms for each system on a spacecraft.
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 'Name is required';
if (value.length < 2) return 'Name must be at least 2 characters';
return null;
case 'callsign':
if (!value.trim()) return 'Callsign is required';
if (!/^[A-Z0-9-]+$/.test(value)) return 'Only uppercase letters, digits, and hyphens';
return null;
case 'rank':
if (!value) return 'Select a rank';
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 }));
// Validate only if the field has been touched
if (touched[field]) {
const error = validate(field, value);
setErrors(prev => ({ ...prev, [field]: error }));
}
};
return (
<form>
<div>
<label>Name</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>
{/* Same pattern for remaining fields */}
</form>
);
}Notice the touched pattern -- we only show errors after the user has left the field (onBlur). We don't want to scare the pilot with alarms before they've even finished entering data!
Handling Server Errors in Forms
The server can return errors that cannot be predicted on the client side -- e.g., "this email is already taken" or "registration limit exceeded".
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) {
// Field-specific errors (e.g., "email already exists")
setErrors(data.fieldErrors);
}
if (data.message) {
// General server error
setServerError(data.message);
}
return;
}
// Success - redirect or show message
} catch (error) {
setServerError('Failed to connect to the base station');
}
};
return (
<form onSubmit={handleSubmit}>
{serverError && (
<div className="server-error-banner">{serverError}</div>
)}
{/* Form fields with field-level errors */}
</form>
);
}try-catch in handleSubmit
Every form submission handler should be wrapped in try-catch. Without it, a network error or unexpected server error will cause an unhandled exception.
const handleSubmit = async (e) => {
e.preventDefault();
setIsSubmitting(true);
setErrors({});
try {
// 1. Local validation
const validationErrors = validateAllFields(formData);
if (Object.keys(validationErrors).length > 0) {
setErrors(validationErrors);
return;
}
// 2. Send to server
const response = await submitToServer(formData);
// 3. Handle server response
if (!response.ok) {
const errorData = await response.json();
throw new Error(errorData.message || 'Server error');
}
// 4. Success
setSuccess(true);
} catch (error) {
// 5. Error handling
setErrors({ submit: error.message });
} finally {
// 6. Always executed - disable loader
setIsSubmitting(false);
}
};UX Best Practices for Error Messages
Good error messages in forms should be:
- Specific -- "Password must be at least 8 characters" instead of "Invalid password"
- Helpful -- tell the user HOW to fix the error
- Visible -- display the error near the field it relates to
- Gentle -- don't show all errors at once before the first submit
- Accessible -- use
aria-invalidandaria-describedbyattributes
<div className="form-field">
<label htmlFor="password">Password</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>Remember -- a form is like a spacecraft's control panel. Every error must be communicated clearly and precisely so that the pilot (user) knows exactly what to fix. Never show mysterious error codes -- always translate them into human-readable language.
Code for this lesson: App.jsx
import React, { useState } from 'react';
import './styles.css';
// Crew member registration form with validation
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 'Name is required';
if (value.length < 2) return 'Name must have at least 2 characters';
return null;
case 'callsign':
if (!value.trim()) return 'Callsign is required';
if (!/^[A-Za-z0-9-]+$/.test(value))
return 'Only letters, digits, and hyphens';
return null;
case 'email':
if (!value.trim()) return 'Email is required';
if (!value.includes('@')) return 'Invalid email format';
return null;
case 'rank':
if (!value) return 'Choose a rank';
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);
// Validate all fields
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 {
// Simulating sending to the server
await new Promise(resolve => setTimeout(resolve, 1000));
// Simulating a server error (50% chance)
if (Math.random() > 0.5) {
throw new Error('Server rejected registration: callsign already exists');
}
setSuccess(true);
} catch (error) {
setServerError(error.message);
} finally {
setIsSubmitting(false);
}
};
if (success) {
return (
<div className="success-panel">
<h2>Registration successful!</h2>
<p>Welcome aboard, {formData.callsign}!</p>
<button onClick={() => { setSuccess(false); setFormData({ name: '', callsign: '', email: '', rank: '' }); setTouched({}); }}>
Register another
</button>
</div>
);
}
return (
<form onSubmit={handleSubmit} className="form">
{serverError && (
<div className="server-error">{serverError}</div>
)}
<div className="field">
<label>Name</label>
<input
value={formData.name}
onChange={(e) => handleChange('name', e.target.value)}
onBlur={() => handleBlur('name')}
className={touched.name && errors.name ? 'input-error' : ''}
placeholder="e.g. John Smith"
/>
{touched.name && errors.name && (
<p className="field-error">{errors.name}</p>
)}
</div>
<div className="field">
<label>Callsign</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="e.g. john@station.space"
/>
{touched.email && errors.email && (
<p className="field-error">{errors.email}</p>
)}
</div>
<div className="field">
<label>Rank</label>
<select
value={formData.rank}
onChange={(e) => handleChange('rank', e.target.value)}
onBlur={() => handleBlur('rank')}
className={touched.rank && errors.rank ? 'input-error' : ''}
>
<option value="">-- Choose a rank --</option>
<option value="cadet">Cadet</option>
<option value="officer">Officer</option>
<option value="commander">Commander</option>
</select>
{touched.rank && errors.rank && (
<p className="field-error">{errors.rank}</p>
)}
</div>
<button type="submit" className="submit-btn" disabled={isSubmitting}>
{isSubmitting ? 'Sending...' : 'Register crew member'}
</button>
</form>
);
}
export default function App() {
return (
<div className="app">
<h1>Crew Registration</h1>
<p className="subtitle">Form validation with error handling</p>
<CrewRegistrationForm />
</div>
);
}Docs entries used in this lesson
Spotted a mistake in this lesson?
Check yourself
Answer the questions from this lesson. Pick an answer to see right away whether it is correct.
1. What is the main advantage of client-side form validation?
2. Why do we use the touched pattern (onBlur) when displaying validation errors?
Hands-on tasks in the game
- Click in order
Click elements in order for the handleSubmit form steps:
- Code editor
Implement a form with validation and error handling
- Horizontal ordering
Arrange the correct syntax for conditionally displaying a field error:
- Vertical ordering
Order the types of form errors from earliest handled to latest: