Semaine 7 · React Fondamentaux

Formulaires
contrôlés

Gérer des formulaires avec useState — champs contrôlés, validation manuelle, gestion des erreurs. La base indispensable avant d'utiliser React Hook Form.

Champs contrôlés
Validation à la main
Tous les types de champs
Pourquoi RHF existe
3 exercices progressifs
Prérequis : S5 Événements · S6 useState
01 — Concept

Champ contrôlé vs champ libre

En React, il existe deux façons de gérer un input. La façon "contrôlée" lie la valeur de l'input au state React — c'est la façon recommandée car React reste le seul maître des données.

Champ libre (non contrôlé)
{"// Le DOM gère la valeur lui-même"}
{"// React ne la connaît pas"}
<input type="text" />

{"// Pour lire → ref ou FormData"}
{"// Pas de synchronisation automatique"}
{"// Pas de validation en temps réel"}
✓ Champ contrôlé
{"// React contrôle la valeur via state"}
const [nom, setNom] = useState('');

<input
  value={nom}
  onChange={e => setNom(e.target.value)}
/>
{"// La valeur est toujours dans nom"}
{"// Validation possible à chaque frappe"}
Pourquoi contrôlé est meilleur
Source unique
Le state React est la seule vérité. Le DOM reflète React, jamais l'inverse.
Validation live
On peut valider à chaque frappe, au focus, au blur — en temps réel.
Reset facile
setNom('') vide le champ immédiatement. Pas besoin de ref ou DOM.
💡
La formule magique d'un champ contrôlé : toujours value={state} + onChange={e => setState(e.target.value)}. Ces deux props ensemble forment la boucle qui synchronise le state et l'affichage.
02 — Un champ

Maîtriser un seul champ en profondeur

Avant de faire un formulaire entier, comprendre parfaitement le cycle d'un seul champ : saisie → state → affichage → actions.

1
Le cycle complet d'un champ contrôlé
Chaque frappe parcourt ce cycle
ChampNom.jsxCycle complet
function ChampNom() {
  const [nom, setNom] = useState('');

  {"// Cycle : frappe → onChange → setNom → rendu → value mis à jour"}

  return (
    <div>
      <label htmlFor="nom">Votre nom</label>

      <input
        id="nom"
        type="text"
        value={nom}                           {"← lie l'input au state"}
        onChange={(e) => setNom(e.target.value)} {"← met à jour le state"}
        placeholder="Ex: Fatou Diallo"
      />

      {"// Utiliser la valeur partout en temps réel"}
      <p>Bonjour, <strong>{nom || 'Inconnu'}</strong> !</p>
      <p>{nom.length} / 50 caractères</p>

      {"// Actions sur la valeur"}
      <button onClick={() => setNom('')}>Effacer</button>
      <button onClick={() => setNom(nom.toUpperCase())}>MAJUSCULES</button>
      <button onClick={() => setNom(nom.trim())}>Supprimer espaces</button>
    </div>
  );
}
htmlFor sur le label + id sur l'input = accessibilité. Cliquer sur le label met le focus sur l'input. C'est une bonne pratique à toujours respecter.
🚨
Piège : value sans onChange = champ en lecture seule. Si on met value={nom} sans onChange, React affiche un avertissement et le champ devient impossible à modifier. Les deux props vont toujours ensemble.
03 — Plusieurs champs

Gérer plusieurs champs proprement

Deux approches pour gérer plusieurs champs : un state par champ (simple et lisible) ou un state objet (compact quand les champs évoluent ensemble).

1
Approche 1 — un useState par champ
La plus simple, recommandée pour 2-3 champs
FormulaireSimple.jsxUn state par champ
function FormulaireConnexion() {
  const [email,      setEmail]      = useState('');
  const [motDePasse, setMotDePasse] = useState('');

  function handleSubmit(e) {
    e.preventDefault();
    console.log({ email, motDePasse });
  }

  function handleReset() {
    setEmail('');
    setMotDePasse('');
  }

  return (
    <form onSubmit={handleSubmit}>

      <div>
        <label htmlFor="email">Email</label>
        <input
          id="email" type="email"
          value={email}
          onChange={e => setEmail(e.target.value)}
        />
      </div>

      <div>
        <label htmlFor="mdp">Mot de passe</label>
        <input
          id="mdp" type="password"
          value={motDePasse}
          onChange={e => setMotDePasse(e.target.value)}
        />
      </div>

      <button type="submit">Connexion</button>
      <button type="button" onClick={handleReset}>Effacer</button>
    </form>
  );
}
2
Approche 2 — un state objet pour tous les champs
Recommandé pour 4+ champs qui forment un ensemble cohérent
FormulaireObjet.jsxState objet
function FormulaireInscription() {

  {"// Un seul state — objet avec tous les champs"}
  const [form, setForm] = useState({
    nom:      '',
    email:    '',
    filiere:  '',
    boursier: false,
  });

  {"// Handler générique — fonctionne pour tous les champs texte"}
  function handleChange(e) {
    const { name, value, type, checked } = e.target;
    setForm(prev => ({
      ...prev,
      {"// checkbox → checked, autres → value"}
      [name]: type === 'checkbox' ? checked : value,
    }));
  }

  function handleSubmit(e) {
    e.preventDefault();
    console.log(form);
  }

  function handleReset() {
    setForm({ nom: '', email: '', filiere: '', boursier: false });
  }

  return (
    <form onSubmit={handleSubmit}>

      {"// name= doit correspondre exactement à la clé du state"}
      <input
        name="nom" value={form.nom}
        onChange={handleChange} placeholder="Nom"
      />

      <input
        name="email" type="email" value={form.email}
        onChange={handleChange} placeholder="Email"
      />

      <select name="filiere" value={form.filiere} onChange={handleChange}>
        <option value="">Choisir...</option>
        <option value="info">Informatique</option>
        <option value="reseaux">Réseaux</option>
      </select>

      <label>
        <input
          name="boursier" type="checkbox"
          checked={form.boursier} onChange={handleChange}
        /> Boursier
      </label>

      <button type="submit">S'inscrire</button>
      <button type="button" onClick={handleReset}>Reset</button>
    </form>
  );
}
La clé [name] dans setForm utilise la propriété calculée de JavaScript — [name] est remplacée par la valeur de la variable name, ce qui permet un handler générique pour tous les champs.
04 — Tous les types de champs

Contrôler chaque type de champ

Chaque type de champ HTML a sa propre façon d'être contrôlé. Les différences sont subtiles mais importantes.

→
Tous les types avec leur prop de valeur
value, checked — et ce qu'on lit dans onChange
tous-les-champs.jsxRéférence
{"// ── TEXT, EMAIL, PASSWORD, NUMBER, TEL ──"}
<input
  type="text"       {"| 'email' | 'password' | 'number' | 'tel'"}
  value={state}    {"← prop : value"}
  onChange={e => setState(e.target.value)} {"← lit : .value"}
/>

{"// ── TEXTAREA ──"}
<textarea
  value={state}
  onChange={e => setState(e.target.value)}
  rows={4}
/>

{"// ── SELECT ──"}
<select
  value={state}    {"← option sélectionnée"}
  onChange={e => setState(e.target.value)}
>
  <option value="a">Option A</option>
</select>

{"// ── CHECKBOX ──"}
<input
  type="checkbox"
  checked={state}  {"← prop : checked (pas value !)"}
  onChange={e => setState(e.target.checked)} {"← lit : .checked"}
/>

{"// ── RADIO ──"}
{['info', 'reseaux', 'cyber'].map(val => (
  <label key={val}>
    <input
      type="radio"
      value={val}
      checked={state === val}   {"← coché si = à la valeur"}
      onChange={e => setState(e.target.value)}
    /> {val}
  </label>
))}
Mémo : tout utilise value + onChange sauf checkbox et radio qui utilisent checked + onChange(e.target.checked). Radio utilise les deux : value pour identifier l'option ET checked pour savoir si elle est sélectionnée.
05 — Validation

Valider les données à la main

Sans librairie, on valide avec un state d'erreurs et des fonctions de vérification. C'est verbeux mais comprendre ce mécanisme explique pourquoi RHF existe.

Pristine
Champ non touché — pas encore d'erreur affichée
✓ Valide
Valeur correcte — feedback positif optionnel
✗ Invalide
Valeur incorrecte — message d'erreur visible
→
Validation au submit + validation au blur
Le pattern standard en React sans librairie
FormulaireValide.jsxValidation manuelle
function FormulaireValide() {
  {"// State des valeurs"}
  const [form, setForm] = useState({ nom: '', email: '', note: '' });

  {"// State des erreurs — même structure que form"}
  const [erreurs, setErreurs] = useState({ nom: '', email: '', note: '' });

  {"// State des champs touchés — pour n'afficher les erreurs qu'après interaction"}
  const [touches, setTouches] = useState({ nom: false, email: false, note: false });

  {"// Fonction de validation — retourne un objet d'erreurs"}
  function valider(valeurs) {
    const errs = { nom: '', email: '', note: '' };

    if (!valeurs.nom.trim()) {
      errs.nom = 'Le nom est obligatoire';
    } else if (valeurs.nom.length < 2) {
      errs.nom = 'Minimum 2 caractères';
    }

    if (!valeurs.email) {
      errs.email = 'L\'email est obligatoire';
    } else if (!valeurs.email.includes('@')) {
      errs.email = 'Format email invalide';
    }

    const note = Number(valeurs.note);
    if (valeurs.note === '') {
      errs.note = 'La note est obligatoire';
    } else if (note < 0 || note > 20) {
      errs.note = 'La note doit être entre 0 et 20';
    }

    return errs;
  }

  {"// onChange — met à jour les valeurs + valide si le champ a déjà été touché"}
  function handleChange(e) {
    const { name, value } = e.target;
    const nouvelleForm = { ...form, [name]: value };
    setForm(nouvelleForm);
    if (touches[name]) {
      setErreurs(valider(nouvelleForm));
    }
  }

  {"// onBlur — marque le champ comme touché et valide"}
  function handleBlur(e) {
    const { name } = e.target;
    setTouches(prev => ({ ...prev, [name]: true }));
    setErreurs(valider(form));
  }

  {"// onSubmit — valide tout d'un coup"}
  function handleSubmit(e) {
    e.preventDefault();
    const errs = valider(form);
    setErreurs(errs);
    {"// Marquer tous les champs comme touchés"}
    setTouches({ nom: true, email: true, note: true });
    {"// Si pas d'erreur → soumettre"}
    const valide = Object.values(errs).every(err => !err);
    if (valide) console.log('Données valides :', form);
  }

  return (
    <form onSubmit={handleSubmit}>

      <div>
        <label>Nom</label>
        <input
          name="nom"
          value={form.nom}
          onChange={handleChange}
          onBlur={handleBlur}
          style={{ borderColor: erreurs.nom && touches.nom ? 'red' : '' }}
        />
        {erreurs.nom && touches.nom && <p style={{color:'red'}}>{erreurs.nom}</p>}
      </div>

      {"// ... même pattern pour email et note ..."}

      <button type="submit">Envoyer</button>
    </form>
  );
}
Le state "touches" est essentiel pour l'UX : on ne montre les erreurs que sur les champs que l'utilisateur a déjà visités. Afficher toutes les erreurs dès le chargement est une mauvaise pratique.
06 — Formulaire complet

Assembler un formulaire complet

Un formulaire d'inscription complet avec état de soumission, feedback visuel et reset — le tout avec useState uniquement.

États nécessaires pour un formulaire complet
états-formulaire.jsxArchitecture
function FormulaireComplet() {

  {"// 1. Les valeurs des champs"}
  const [form, setForm] = useState({
    nom: '', email: '', filiere: '',
    note: '', boursier: false, commentaire: '',
  });

  {"// 2. Les erreurs de validation"}
  const [erreurs, setErreurs] = useState({});

  {"// 3. Les champs visités (touched)"}
  const [touches, setTouches] = useState({});

  {"// 4. L'état de soumission"}
  const [envoiEnCours, setEnvoiEnCours] = useState(false);
  const [succes,       setSucces]       = useState(false);
  const [erreurApi,    setErreurApi]    = useState('');

  {"// Handler générique"}
  function handleChange(e) {
    const { name, value, type, checked } = e.target;
    const nouvelleForm = {
      ...form, [name]: type === 'checkbox' ? checked : value
    };
    setForm(nouvelleForm);
    if (touches[name]) setErreurs(valider(nouvelleForm));
  }

  function handleBlur(e) {
    setTouches(prev => ({ ...prev, [e.target.name]: true }));
    setErreurs(valider(form));
  }

  async function handleSubmit(e) {
    e.preventDefault();
    const errs = valider(form);
    setErreurs(errs);
    setTouches({ nom: true, email: true, filiere: true, note: true });

    if (Object.values(errs).some(err => err)) return; {"← arrêter si erreur"}

    setEnvoiEnCours(true);
    setErreurApi('');
    try {
      await new Promise(res => setTimeout(res, 1500)); {"← simuler API"}
      setSucces(true);
      setForm({ nom: '', email: '', filiere: '', note: '', boursier: false, commentaire: '' });
      setTouches({});
    } catch {
      setErreurApi('Erreur serveur. Réessayez.');
    } finally {
      setEnvoiEnCours(false);
    }
  }

  if (succes) {
    return (
      <div>
        <p>✓ Inscription réussie !</p>
        <button onClick={() => setSucces(false)}>Nouvelle inscription</button>
      </div>
    );
  }

  return (
    <form onSubmit={handleSubmit}>
      {"/* ... les champs ... */"}
      {erreurApi && <p style={{color:'red'}}>{erreurApi}</p>}
      <button type="submit" disabled={envoiEnCours}>
        {envoiEnCours ? 'Envoi...' : 'S\'inscrire'}
      </button>
    </form>
  );
}
07 — Limites & pourquoi RHF

Les limites de l'approche manuelle

L'approche manuelle fonctionne bien pour les petits formulaires. Au-delà, elle devient difficile à maintenir — c'est exactement le problème que React Hook Form résout.

Ce qui devient pénible manuellement
Volume de code
5 champs = 5 states valeurs + 1 state erreurs + 1 state touches + handlers. ~100 lignes de logique pour un formulaire basique.
Performance
Chaque frappe déclenche un re-render complet. Sur un formulaire de 20 champs, c'est coûteux.
Validation complexe
Vérifier les formats (email, téléphone, URL) manuellement avec regex est fastidieux et source d'erreurs.
Validation croisée
Vérifier que deux mots de passe sont identiques ou qu'une date de fin est après une date de début devient complexe.
🌉
Le pont vers S8 — React Hook Form + Zod
Vous venez de comprendre pourquoi React Hook Form existe. Il remplace tout ce code manuel en quelques lignes. useForm() gère les valeurs, les erreurs, les touches et la soumission. Zod remplace votre fonction valider() par un schéma déclaratif. Le résultat : 40 lignes au lieu de 150, zéro re-render inutile, validation complète.

Récapitulatif — les patterns à retenir
ChampProp de contrôleCe qu'on lit dans onChange
input text / email / password / numbervalue={state}e.target.value
textareavalue={state}e.target.value
selectvalue={state}e.target.value
checkboxchecked={state}e.target.checked
radiochecked={state === value}e.target.value
08 — Validation

Quiz & Travaux pratiques

4 questions de validation puis 3 exercices progressifs — du champ unique au formulaire complet avec validation.

1. Qu'est-ce qu'un champ contrôlé en React ?
2. Que se passe-t-il si on met value={state} sur un input sans onChange ?
3. Pour une checkbox contrôlée, quelle est la bonne combinaison de props ?
4. Pourquoi utiliser un state "touches" dans la validation ?

S7 — Travaux Pratiques · 3 exercices
Formulaires contrôlés de A à Z
1
Formulaire de connexion avec validation basique
State objet avec email et motDePasse. Handler générique. Validation au submit : email doit contenir "@" et "."; mot de passe doit avoir au moins 6 caractères. Affichez les messages d'erreur sous chaque champ. Le bouton submit est désactivé pendant l'envoi (simulez 1.5s). Après succès, affichez "Connexion réussie !" et un bouton "Retour". Si email = "admin@test.com" → succès, sinon → erreur "Email ou mot de passe incorrect".
2
Formulaire multi-types avec validation au blur
Formulaire d'inscription avec : nom (texte, min 2 car.), filiere (select, requis), note (number, 0–20), boursier (checkbox), commentaire (textarea, max 200 car.), genre (radio : M/F/Autre). Utilisez un state objet + handler générique. Validez à l'événement onBlur sur chaque champ (pas au submit). Affichez le compteur de caractères du commentaire en temps réel. Affichez un résumé des données sous le formulaire uniquement après soumission réussie.
3
Formulaire d'édition avec préchargement
Simulez un chargement de données existantes : après 1s (setTimeout), initialisez le state du formulaire avec des données pré-remplies (un étudiant fictif). Affichez un spinner pendant le chargement. Validez à la soumission. Après soumission réussie, comparez les données initiales et les données modifiées : affichez uniquement les champs qui ont changé sous forme de résumé "Champs modifiés : nom, note". Ajoutez un bouton "Annuler les modifications" qui remet les valeurs d'origine.