Un formulaire de dix champs avec une validation simple ne pose jamais de problème. Un formulaire de cinquante champs, avec des sections conditionnelles, de la validation croisée entre champs et un appel réseau pour vérifier l'unicité d'un email, devient vite un formulaire qui retape à chaque frappe, qui valide trop tôt ou trop tard, et dont l'état se désynchronise de l'affichage. Ce billet détaille où ça casse concrètement et comment structurer l'état pour que ça reste tenable.
Le problème : re-renders en cascade et état fragmenté
Le pattern naïf consiste à mettre chaque champ dans un useState séparé au niveau du composant parent, puis à passer value et onChange en props à chaque enfant.
function RegistrationForm() {
const [firstName, setFirstName] = useState('');
const [lastName, setLastName] = useState('');
const [email, setEmail] = useState('');
const [country, setCountry] = useState('');
const [vatNumber, setVatNumber] = useState('');
// ... quinze autres champs
return (
<form>
<TextField value={firstName} onChange={setFirstName} />
<TextField value={lastName} onChange={setLastName} />
{/* ... */}
</form>
);
}
Chaque frappe sur firstName déclenche un re-render du composant RegistrationForm entier, ce qui re-rend tous ses enfants sauf s'ils sont mémoïsés individuellement. Avec cinquante champs et une validation synchrone sur chacun (regex, longueur, format), la frappe devient perceptiblement lente sur des machines modestes, et encore plus sur mobile.
Le second symptôme, plus insidieux : la validation croisée. Le champ vatNumber ne devient obligatoire que si country appartient à l'UE. Avec un état fragmenté en useState indépendants, cette règle finit éparpillée dans des useEffect qui se déclenchent les uns les autres, produisant des re-validations en boucle ou des états incohérents pendant une frappe.
Pourquoi ça arrive : React re-rend par défaut, pas par exception
React ne sait pas qu'une mise à jour de firstName n'affecte pas l'affichage de vatNumber. Sans mémoïsation explicite (React.memo, useMemo, useCallback) ou sans une architecture qui isole la souscription aux changements, chaque setState au niveau racine déclenche la réconciliation de tout l'arbre sous ce composant.
La validation ajoute une seconde couche de complexité : valider à chaque onChange (mode: 'onChange' dans la terminologie de React Hook Form) donne un feedback instantané mais multiplie les calculs, alors que valider seulement au submit (mode: 'onSubmit') donne une mauvaise expérience sur les champs qui ont un coût d'erreur élevé (mot de passe, email).
Diagnostiquer : profiler avant d'optimiser à l'aveugle
React DevTools Profiler montre precisément quels composants re-rendent à chaque frappe et pourquoi (why did this render). Avant de réécrire l'architecture, il faut confirmer que le ralentissement vient bien des re-renders et pas, par exemple, d'une validation regex coûteuse exécutée en synchrone sur le thread principal.
// Mesurer le coût réel d'un re-render de section
import { Profiler } from 'react';
function onRenderCallback(id, phase, actualDuration) {
if (actualDuration > 16) {
console.warn(`${id} (${phase}) a pris ${actualDuration.toFixed(1)}ms`);
}
}
<Profiler id="AddressSection" onRender={onRenderCallback}>
<AddressSection />
</Profiler>
Si actualDuration dépasse régulièrement 16 ms (le budget d'une frame à 60 fps) sur une section qui n'a pas changé visuellement, c'est un signal clair de re-render inutile.
La correction : état non contrôlé + validation ciblée
Confier l'état des champs à une bibliothèque de formulaires
React Hook Form (ou Formik, avec des compromis différents) résout le problème de fond en gardant les champs non contrôlés par défaut : la valeur vit dans le DOM via des refs, et React ne re-rend que les composants explicitement souscrits à un champ donné via useWatch ou le rendu conditionnel du message d'erreur.
import { useForm, useWatch } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { z } from 'zod';
const schema = z.object({
country: z.string().min(1, 'Pays requis'),
vatNumber: z.string().optional(),
}).refine(
(data) => !isEuCountry(data.country) || Boolean(data.vatNumber),
{ message: 'Numéro de TVA requis pour un pays de l\'UE', path: ['vatNumber'] }
);
function RegistrationForm() {
const { register, control, handleSubmit, formState: { errors } } = useForm({
resolver: zodResolver(schema),
mode: 'onBlur',
});
const country = useWatch({ control, name: 'country' });
const vatRequired = isEuCountry(country);
return (
<form onSubmit={handleSubmit(onSubmit)}>
<select {...register('country')}>{/* options */}</select>
{vatRequired && (
<input {...register('vatNumber')} placeholder="Numéro de TVA" />
)}
{errors.vatNumber && <span>{errors.vatNumber.message}</span>}
<button type="submit">Valider</button>
</form>
);
}
La validation croisée (refine de Zod) vit à un seul endroit, dans le schéma, plutôt qu'éclatée dans des useEffect. Seul le composant qui lit country via useWatch re-rend quand ce champ change ; les autres champs enregistrés via register ne déclenchent aucun re-render au niveau du parent.
Débouncer la validation asynchrone coûteuse
Pour une vérification réseau (unicité d'un email, par exemple), valider à chaque frappe surchargerait le serveur et donnerait un feedback qui clignote. Le debounce associé à mode: 'onBlur' ou à une validation différée évite ça :
import { useState, useCallback } from 'react';
import { useDebouncedCallback } from 'use-debounce';
function EmailField({ register, setError, clearErrors }) {
const [checking, setChecking] = useState(false);
const checkEmailAvailability = useDebouncedCallback(async (email) => {
setChecking(true);
try {
const res = await fetch(`/api/users/check-email?email=${encodeURIComponent(email)}`);
const { available } = await res.json();
if (!available) {
setError('email', { message: 'Cet email est déjà utilisé' });
} else {
clearErrors('email');
}
} finally {
setChecking(false);
}
}, 500);
return (
<input
{...register('email')}
onBlur={(e) => checkEmailAvailability(e.target.value)}
/>
);
}
Le debounce de 500 ms absorbe les frappes rapides ; useCallback/useDebouncedCallback garantit que la fonction debouncée n'est pas recréée à chaque render, ce qui casserait le debounce lui-même.
Tester la logique de validation sans fragiliser la suite
Un formulaire complexe mal testé finit toujours par régresser silencieusement : quelqu'un modifie une règle de validation croisée pour un cas particulier et casse un autre cas qui n'était couvert par aucun test. Tester au niveau du schéma Zod isolément (sans monter de composant React) couvre la logique métier pure, rapidement et sans fragilité liée au DOM :
// vat-schema.test.js
import { schema } from './registration-schema';
test('exige un numéro de TVA pour un pays de l\'UE', () => {
const result = schema.safeParse({ country: 'FR', vatNumber: '' });
expect(result.success).toBe(false);
expect(result.error.issues[0].path).toEqual(['vatNumber']);
});
test('n\'exige pas de numéro de TVA hors UE', () => {
const result = schema.safeParse({ country: 'US', vatNumber: '' });
expect(result.success).toBe(true);
});
Pour le comportement d'interface (le champ vatNumber qui apparaît ou disparaît réellement à l'écran), React Testing Library avec user-event reste la bonne couche, en interagissant avec le formulaire comme le ferait un utilisateur plutôt qu'en inspectant l'état interne des hooks :
import { render, screen } from '@testing-library/react';
import userEvent from '@testing-library/user-event';
import { RegistrationForm } from './RegistrationForm';
test('affiche le champ TVA uniquement pour un pays de l\'UE', async () => {
const user = userEvent.setup();
render(<RegistrationForm />);
expect(screen.queryByPlaceholderText(/numéro de TVA/i)).not.toBeInTheDocument();
await user.selectOptions(screen.getByRole('combobox', { name: /pays/i }), 'FR');
expect(screen.getByPlaceholderText(/numéro de TVA/i)).toBeInTheDocument();
});
Cette répartition (schéma testé en isolation, comportement visible testé via l'interaction utilisateur) évite le piège classique des tests de formulaire qui simulent des fireEvent.change bruts sur des inputs non contrôlés : avec React Hook Form, la valeur vit dans le DOM via des refs, donc seule une vraie interaction utilisateur déclenche correctement la mise à jour et la re-validation.
Les compromis
Passer les champs en non contrôlés via React Hook Form rend plus difficile la transformation de valeur en temps réel (formatage d'un numéro de carte bancaire pendant la frappe, par exemple) : il faut alors passer par un Controller qui réintroduit un composant contrôlé pour ce champ précis, en acceptant son coût de re-render localisé.
Sur un formulaire très dynamique où presque chaque champ dépend d'un autre (formulaire de configuration produit avec des dizaines de règles conditionnelles), même cette architecture peut devenir difficile à suivre. Dans ce cas, modéliser explicitement l'état comme une machine à états (XState, ou un réducteur useReducer avec des actions nommées) rend les transitions traçables, au prix d'un code plus verbeux qu'un simple schéma de validation.
Quand la bibliothèque de formulaire ne suffit pas
Si la validation dépend de règles métier qui changent le schéma lui-même selon le contexte (un formulaire multi-tenant où chaque client a des champs obligatoires différents), un schéma statique défini au chargement du composant ne suffit plus : il faut générer le schéma dynamiquement à partir d'une configuration serveur, et s'assurer que ce schéma dynamique est bien mémoïsé pour ne pas recréer le resolver à chaque render.
Le point à retenir : la lenteur d'un formulaire React vient presque toujours d'un état trop centralisé et d'une validation non différenciée entre feedback instantané et vérification coûteuse. Isoler les souscriptions aux champs et séparer validation synchrone locale de validation asynchrone débouncée règle l'essentiel des cas, avant même de penser à une optimisation plus fine.
