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.
{"// 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"}
{"// 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"}
setNom('') vide le champ immédiatement. Pas besoin de ref ou DOM.value={state} + onChange={e => setState(e.target.value)}. Ces deux props ensemble forment la boucle qui synchronise le state et l'affichage.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.
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> ); }
value={nom} sans onChange, React affiche un avertissement et le champ devient impossible à modifier. Les deux props vont toujours ensemble.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).
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> ); }
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> ); }
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.
{"// ── 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> ))}
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.
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> ); }
Assembler un formulaire complet
Un formulaire d'inscription complet avec état de soumission, feedback visuel et reset — le tout avec useState uniquement.
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> ); }
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.
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.
| Champ | Prop de contrôle | Ce qu'on lit dans onChange |
|---|---|---|
| input text / email / password / number | value={state} | e.target.value |
| textarea | value={state} | e.target.value |
| select | value={state} | e.target.value |
| checkbox | checked={state} | e.target.checked |
| radio | checked={state === value} | e.target.value |
Quiz & Travaux pratiques
4 questions de validation puis 3 exercices progressifs — du champ unique au formulaire complet avec validation.
value={state} sur un input sans onChange ?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".
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.