JavaScript and React course ยท Module 16: Error Handling and Suspense

Error Handling in Forms

5 min read ยท
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:

  1. Specific -- "Password must be at least 8 characters" instead of "Invalid password"
  2. Helpful -- tell the user HOW to fix the error
  3. Visible -- display the error near the field it relates to
  4. Gentle -- don't show all errors at once before the first submit
  5. Accessible -- use aria-invalid and aria-describedby attributes
<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. 1. What is the main advantage of client-side form validation?

  2. 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:

  1. QuestionClient-Side Validation
  2. QuestionThe touched Pattern in Forms
  3. Click in orderhandleSubmit Steps with try-catch
  4. Coding taskPractice: Form Validation
  5. Put in orderDisplaying Form Field Errors
  6. Put in orderTypes of Form Errors

Useful articles