Semaine 8 · React Avancé

Formulaires professionnels

La stack complète utilisée en entreprise : MUI pour l'interface, React Hook Form pour la gestion des champs, Zod pour la validation des données.

MUI v6
React Hook Form
Zod
Installation & configuration
Schémas de validation Zod
Champs MUI contrôlés
3 formulaires progressifs
Prérequis : S5 Événements · S6 useState · S7 useEffect
01 — La stack

Pourquoi cette combinaison ?

Faire un formulaire en React "à la main" avec useState devient vite complexe : gérer chaque champ, les erreurs, la soumission, les états loading… Cette stack divise chaque responsabilité clairement.

MUI
Composants d'interface
TextField, Select, Checkbox, Button… Des composants React prêts à l'emploi, accessibles, avec le design Material (Google).
RHF
Gestion des champs
Enregistre les champs, surveille les valeurs, gère la soumission, déclenche la validation au bon moment. Zéro re-render inutile.
Zod
Validation des données
Définit le schéma de ce qu'on attend (type, format, taille…). Produit des messages d'erreur clairs. Réutilisable côté API aussi.
Sans la stack vs avec la stack
✗ Tout à la main — useState seul
{"// Un champ = 3 lignes de state"}
const [nom, setNom]         = useState('');
const [nomErr, setNomErr]   = useState('');
const [email, setEmail]     = useState('');
const [emailErr, setEmailErr]= useState('');
{"// × 5 champs = 10 useState !"}
{"// + logique de validation manuelle"}
{"// + gestion des re-renders"}
{"// = ~150 lignes pour un formulaire"}
✓ Avec la stack — propre et court
{"// Zod : définir les règles une fois"}
const schema = z.object({
  nom: z.string().min(2),
  email: z.string().email(),
});

{"// RHF : brancher automatiquement"}
const { register, handleSubmit,
  formState: { errors }
} = useForm({ resolver: zodResolver(schema) });
{"// = ~40 lignes, tout géré"}
💡
Ordre d'apprentissage dans ce chapitre : on commence par Zod (les règles), puis React Hook Form (la gestion), puis MUI (l'affichage). On assemble tout à la fin. Chaque brique se comprend seule avant d'être combinée.
02 — Installation

Installer et configurer la stack

Trois packages à installer dans un projet React existant (créé avec Vite ou Create React App).

Étape 1 — Installer les packages
Une seule commande pour tout installer
npm
npm install @mui/material @emotion/react @emotion/styled @mui/icons-material react-hook-form zod @hookform/resolvers
Ce que chaque package fait :
explication packages
@mui/material         → composants MUI (TextField, Button…)
@emotion/react        → dépendance CSS-in-JS de MUI
@emotion/styled       → dépendance CSS-in-JS de MUI
@mui/icons-material   → icônes Material (optionnel mais utile)
react-hook-form       → gestion des formulaires
zod                   → validation par schéma
@hookform/resolvers   → pont entre RHF et Zod
Étape 2 — Configurer MUI dans main.jsx
Envelopper l'application dans le ThemeProvider
main.jsxMUI Setup
import React       from 'react';
import ReactDOM    from 'react-dom/client';
import { ThemeProvider, CssBaseline } from '@mui/material';
import { createTheme } from '@mui/material/styles';
import App         from './App';

{"// Thème par défaut — personnalisable"}
const theme = createTheme({
  palette: {
    primary: { main: '#1565C0' },
  },
  typography: {
    fontFamily: 'Space Grotesk, sans-serif',
  },
});

ReactDOM.createRoot(document.getElementById('root')).render(
  <ThemeProvider theme={theme}>
    <CssBaseline />  {"← reset CSS global de MUI"}
    <App />
  </ThemeProvider>
);
✓
CssBaseline est l'équivalent MUI d'un reset CSS. Il normalise les styles entre les navigateurs et applique les styles de base de Material Design. Toujours l'inclure.
03 — Zod

Définir les règles avec Zod

Zod permet de décrire la forme et les contraintes des données avec un schéma JavaScript. Ce schéma devient la source de vérité unique pour la validation — côté formulaire et côté API.

Les types Zod de base
Chaque type correspond à un type JavaScript
z.string() z.number() z.boolean() z.date() z.array() z.object() z.enum()
types-zod.jsZod
import { z } from 'zod';

{"// Chaîne de caractères"}
z.string()
z.string().min(2, 'Minimum 2 caractères')
z.string().max(50)
z.string().email('Email invalide')
z.string().url('URL invalide')
z.string().regex(/^\d{9}$/, 'Format: 9 chiffres')
z.string().nonempty('Champ obligatoire')

{"// Nombre"}
z.number().min(0, 'Note >= 0')
z.number().max(20, 'Note <= 20')
z.number().int('Nombre entier requis')
z.number().positive('Doit être positif')

{"// Enum (valeurs prédéfinies)"}
z.enum(['info', 'reseaux', 'cyber'])

{"// Optionnel"}
z.string().optional()   {"// peut être undefined"}
z.string().nullable()  {"// peut être null"}
→
Construire un schéma complet avec z.object()
Un objet Zod = un formulaire
schema-etudiant.jsSchéma
import { z } from 'zod';

export const schemaEtudiant = z.object({

  nom: z.string()
    .min(2, 'Le nom doit avoir au moins 2 caractères')
    .max(50, 'Le nom ne peut pas dépasser 50 caractères'),

  email: z.string()
    .email('Adresse email invalide')
    .nonempty('L\'email est obligatoire'),

  filiere: z.enum(['info', 'reseaux', 'cyber'], {
    errorMap: () => ({ message: 'Veuillez choisir une filière' })
  }),

  note: z.number({
    invalid_type_error: 'La note doit être un nombre'
  })
    .min(0,  'La note minimum est 0')
    .max(20, 'La note maximum est 20'),

  boursier: z.boolean().default(false),

  telephone: z.string()
    .regex(/^\+?[\d\s\-]{8,15}$/, 'Numéro invalide')
    .optional(),  {"← champ facultatif"}

});
Le schéma est un fichier séparé (schema-etudiant.js). Il peut être importé dans le formulaire React ET dans une API Node.js — c'est tout l'intérêt : une seule source de validation.
Validation croisée — confirmer un mot de passe
.refine() pour des règles qui comparent plusieurs champs
schema-mot-de-passe.jsrefine
const schemaMotDePasse = z.object({
  motDePasse:        z.string().min(8, '8 caractères minimum'),
  confirmerMotDePasse: z.string(),
}).refine(
  (data) => data.motDePasse === data.confirmerMotDePasse,
  {
    message: 'Les mots de passe ne correspondent pas',
    path: ['confirmerMotDePasse'],  {"← sur quel champ afficher l'erreur"}
  }
);
04 — React Hook Form

Gérer les champs avec useForm

React Hook Form fournit un hook useForm() qui gère tout : enregistrement des champs, récupération des valeurs, déclenchement de la validation, état du formulaire (loading, erreurs…).

1
Ce que useForm() retourne
Les outils essentiels
useForm-dossier.jsxRHF
import { useForm } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import { schemaEtudiant } from './schema-etudiant';

const {
  register,          {"← enregistre un champ (name, onChange, onBlur, ref)"}
  handleSubmit,      {"← wrapper pour la soumission"}
  formState: {
    errors,          {"← objet { nomChamp: { message: '...' } }"}
    isSubmitting,    {"← true pendant la soumission"}
    isValid,         {"← true si pas d'erreurs"}
    isDirty,         {"← true si l'utilisateur a modifié quelque chose"}
  },
  reset,             {"← remet le formulaire à zéro"}
  watch,             {"← observer la valeur d'un champ en temps réel"}
  setValue,          {"← modifier la valeur d'un champ programmatiquement"}
} = useForm({
  resolver: zodResolver(schemaEtudiant),   {"← brancher Zod"}
  defaultValues: {                           {"← valeurs initiales"}
    nom:      '',
    email:    '',
    filiere:  '',
    note:     0,
    boursier: false,
  },
  mode: 'onBlur',   {"← valider quand l'utilisateur quitte le champ"}
});
mode: 'onBlur' valide quand l'user quitte le champ. 'onChange' valide à chaque frappe (plus agressif). 'onSubmit' valide seulement à la soumission (moins de feedback). 'onBlur' est le meilleur compromis UX.
2
register() — enregistrer un champ natif
Pour les inputs HTML ordinaires (sans MUI)
register-basique.jsxregister
function FormulaireBasique() {
  const { register, handleSubmit, formState: { errors } } = useForm({
    resolver: zodResolver(schemaEtudiant),
  });

  function onSubmit(data) {
    {"// data est l'objet validé — types corrects garantis par Zod"}
    console.log(data); {"// { nom: 'Fatou', email: '...', note: 17, ... }"}
  }

  return (
    <form onSubmit={handleSubmit(onSubmit)}>

      {"// register() injecte name, onChange, onBlur, ref"}
      <input {...register('nom')} placeholder="Nom" />
      {errors.nom && <p>{errors.nom.message}</p>}

      <input {...register('email')} placeholder="Email" />
      {errors.email && <p>{errors.email.message}</p>}

      <button type="submit">Envoyer</button>
    </form>
  );
}
Le spread {...register('nom')} injecte automatiquement name, onChange, onBlur et ref sur l'input. C'est pour ça que RHF ne provoque aucun re-render inutile : il n'utilise pas useState.
3
Controller — pour les composants contrôlés (MUI)
Quand le composant UI ne supporte pas les refs HTML
controller-mui.jsxController
import { Controller } from 'react-hook-form';
import { TextField } from '@mui/material';

{"// Controller est un wrapper RHF pour les composants UI tiers"}
<Controller
  name="nom"
  control={control}    {"← vient de useForm()"}
  render={({ field, fieldState }) => (
    <TextField
      {...field}           {"← injecte value, onChange, onBlur, ref"}
      label="Nom complet"
      error={!!fieldState.error}
      helperText={fieldState.error?.message}
      fullWidth
    />
  )}
/>
On utilise Controller (pas register) avec MUI parce que les composants MUI sont des composants contrôlés qui ont besoin de value et onChange — Controller les fournit via le render prop.
05 — MUI

Les composants de formulaire MUI

MUI fournit des composants prêts à l'emploi pour chaque type de champ. Chacun accepte des props spécifiques pour afficher les erreurs et messages d'aide.

1
TextField — champ texte universel
Remplace input, textarea — tout en un
TextField.jsxMUI
import { TextField } from '@mui/material';

{"// Champ texte simple"}
<TextField
  label="Nom complet"          {"← label flottant"}
  placeholder="Ex: Fatou Diallo"
  variant="outlined"            {"← outlined | filled | standard"}
  fullWidth                      {"← prend toute la largeur"}
  error={!!errors.nom}           {"← true = bordure rouge"}
  helperText={errors.nom?.message} {"← message sous le champ"}
/>

{"// Champ email"}
<TextField label="Email" type="email" fullWidth />

{"// Champ nombre"}
<TextField label="Note" type="number"
  inputProps={{ min: 0, max: 20 }} fullWidth />

{"// Textarea multilignes"}
<TextField label="Commentaire" multiline rows={4} fullWidth />
error={!!errors.nom} convertit l'objet erreur en booléen. L'opérateur !! transforme un objet (truthy) en true et undefined/null (falsy) en false.
2
Select MUI — menu déroulant
FormControl + InputLabel + Select + MenuItem
SelectMUI.jsxMUI Select
import {
  FormControl, InputLabel, Select,
  MenuItem, FormHelperText
} from '@mui/material';

<FormControl fullWidth error={!!errors.filiere}>
  <InputLabel>Filière</InputLabel>
  <Select
    label="Filière"
    defaultValue=""
    {...register('filiere')}
  >
    <MenuItem value=""><em>-- Choisir --</em></MenuItem>
    <MenuItem value="info">Informatique</MenuItem>
    <MenuItem value="reseaux">Réseaux</MenuItem>
    <MenuItem value="cyber">Cybersécurité</MenuItem>
  </Select>
  <FormHelperText>{errors.filiere?.message}</FormHelperText>
</FormControl>
MUI Select nécessite FormControl + InputLabel pour le label flottant. FormHelperText affiche le message d'erreur sous le select. Ces composants forment un ensemble cohérent.
3
Checkbox et Switch MUI
Utiliser Controller pour les champs booléens
CheckboxMUI.jsxMUI Checkbox
import { Checkbox, FormControlLabel, Switch } from '@mui/material';
import { Controller } from 'react-hook-form';

{"// Checkbox avec Controller"}
<Controller
  name="boursier"
  control={control}
  render={({ field }) => (
    <FormControlLabel
      label="Étudiant boursier"
      control={
        <Checkbox
          checked={field.value}     {"← value → checked"}
          onChange={field.onChange}
        />
      }
    />
  )}
/>

{"// Switch (même structure que Checkbox)"}
<FormControlLabel
  label="Notifications activées"
  control={<Switch {...field} checked={field.value} />}
/>
Checkbox MUI utilise checked (pas value) pour l'état coché. On passe field.value à checked et field.onChange à onChange. C'est pourquoi Controller est nécessaire ici.
06 — Tout ensemble

Formulaire complet MUI + RHF + Zod

Voici le formulaire d'inscription étudiant complet. C'est le modèle de référence à suivre pour tous vos formulaires.

Étape 1 — Le schéma (séparé)
schemas/etudiant.schema.jsZod
import { z } from 'zod';

export const schemaEtudiant = z.object({
  nom:      z.string().min(2, 'Minimum 2 caractères'),
  email:    z.string().email('Email invalide'),
  filiere:  z.enum(['info', 'reseaux', 'cyber'], {
              errorMap: () => ({ message: 'Filière requise' })
            }),
  note:     z.number().min(0).max(20),
  boursier: z.boolean().default(false),
});

{"// Type TypeScript inféré automatiquement (bonus)"}
{"// export type EtudiantForm = z.infer;"}
Étape 2 — Le formulaire complet
FormulaireEtudiant.jsxComplet
import { useForm, Controller } from 'react-hook-form';
import { zodResolver } from '@hookform/resolvers/zod';
import {
  Box, TextField, FormControl, InputLabel,
  Select, MenuItem, FormHelperText,
  FormControlLabel, Checkbox,
  Button, Alert, CircularProgress, Stack
} from '@mui/material';
import { schemaEtudiant } from './schemas/etudiant.schema';

function FormulaireEtudiant({ onSuccess }) {

  const {
    register, control, handleSubmit, reset,
    formState: { errors, isSubmitting, isSubmitSuccessful }
  } = useForm({
    resolver: zodResolver(schemaEtudiant),
    defaultValues: { nom: '', email: '', filiere: '', note: 0, boursier: false },
    mode: 'onBlur',
  });

  async function onSubmit(data) {
    await new Promise(res => setTimeout(res, 1500)); {"← simuler API"}
    console.log('Données validées :', data);
    onSuccess?.(data);
    reset();
  }

  return (
    <Box
      component="form"
      onSubmit={handleSubmit(onSubmit)}
      noValidate
    >
      <Stack spacing={3}>

        {"/* Champ Nom — register() suffit */"}
        <TextField
          label="Nom complet"
          fullWidth
          error={!!errors.nom}
          helperText={errors.nom?.message}
          {...register('nom')}
        />

        {"/* Champ Email */"}
        <TextField
          label="Email" type="email" fullWidth
          error={!!errors.email}
          helperText={errors.email?.message}
          {...register('email')}
        />

        {"/* Select Filière */"}
        <FormControl fullWidth error={!!errors.filiere}>
          <InputLabel>Filière</InputLabel>
          <Select label="Filière" defaultValue=""
            {...register('filiere')}>
            <MenuItem value="info">Informatique</MenuItem>
            <MenuItem value="reseaux">Réseaux</MenuItem>
            <MenuItem value="cyber">Cybersécurité</MenuItem>
          </Select>
          <FormHelperText>{errors.filiere?.message}</FormHelperText>
        </FormControl>

        {"/* Champ Note */"}
        <TextField
          label="Note /20" type="number" fullWidth
          inputProps={{ min: 0, max: 20 }}
          error={!!errors.note}
          helperText={errors.note?.message}
          {...register('note', { valueAsNumber: true })}
        />

        {"/* Checkbox Boursier — Controller obligatoire */"}
        <Controller
          name="boursier" control={control}
          render={({ field }) => (
            <FormControlLabel label="Étudiant boursier"
              control={<Checkbox checked={field.value} onChange={field.onChange} />}
            />
          )}
        />

        {"/* Message succès */"}
        {isSubmitSuccessful && (
          <Alert severity="success">
            Inscription enregistrée avec succès !
          </Alert>
        )}

        {"/* Bouton avec état loading */"}
        <Button
          type="submit"
          variant="contained"
          size="large"
          disabled={isSubmitting}
          startIcon={isSubmitting && <CircularProgress size={18} />}
        >
          {isSubmitting ? 'Envoi...' : 'S\'inscrire'}
        </Button>

      </Stack>
    </Box>
  );
}
⚠️
valueAsNumber pour les champs number. Par défaut, tous les inputs HTML retournent une string. Zod attend un number pour le champ note. L'option valueAsNumber: true dans register() fait la conversion automatiquement.
07 — Cas avancés

Patterns avancés courants

Quelques patterns qu'on retrouve dans presque tous les projets professionnels.

watch() — observer un champ en temps réel
Afficher ou cacher des champs selon d'autres valeurs
watch-exemple.jsxwatch
const { watch, register } = useForm(...);

{"// Observer la valeur d'un champ"}
const filiere = watch('filiere');

return (
  <div>
    {"/* Select filière */"}
    <Select {...register('filiere')}>...</Select>

    {"/* Champ qui apparaît seulement si filiere = 'cyber' */"}
    {filiere === 'cyber' && (
      <TextField
        label="Certification sécurité (optionnel)"
        {...register('certification')}
        fullWidth
      />
    )}
  </div>
);
reset() — pré-remplir pour l'édition
Charger les données existantes dans le formulaire
edition-etudiant.jsxreset
function FormulaireEdition({ etudiantId }) {
  const { reset, ...rest } = useForm({ resolver: zodResolver(schema) });

  {"// Charger les données depuis l'API, puis pré-remplir"}
  useEffect(() => {
    async function charger() {
      const etudiant = await fetchEtudiant(etudiantId);

      {"// reset() remplit tous les champs d'un coup"}
      reset({
        nom:      etudiant.nom,
        email:    etudiant.email,
        filiere:  etudiant.filiere,
        note:     etudiant.note,
        boursier: etudiant.boursier,
      });
    }
    charger();
  }, [etudiantId, reset]);

  return <form>...</form>;
}
setError() — erreurs serveur dans le formulaire
Afficher une erreur retournée par l'API sur le bon champ
erreur-serveur.jsxsetError
const { setError, handleSubmit } = useForm(...);

async function onSubmit(data) {
  try {
    await inscrireEtudiant(data);
  } catch (err) {
    {"// L'API retourne : { field: 'email', message: 'Email déjà utilisé' }"}
    if (err.field) {
      setError(err.field, {
        type: 'server',
        message: err.message,
      });
    } else {
      {"// Erreur globale (pas liée à un champ)"}
      setError('root', { message: 'Une erreur est survenue. Réessayez.' });
    }
  }
}

{"// Dans le JSX — afficher l'erreur root"}
{errors.root && <Alert severity="error">{errors.root.message}</Alert>}

Récapitulatif — quand utiliser register vs Controller
ComposantUtiliserPourquoi
input HTML natifregister()Supporte ref natif
MUI TextFieldregister()Supporte ref via inputRef
MUI Selectregister()Supporte ref natif
MUI CheckboxControllerBesoin de checked, pas value
MUI SwitchControllerBesoin de checked, pas value
MUI DatePickerControllerComposant contrôlé sans ref
React SelectControllerAPI différente (onChange reçoit l'objet option)
08 — Validation

Quiz & Travaux pratiques

4 questions pour valider votre compréhension, puis 3 exercices progressifs du plus simple au plus complet.

1. Quel est le rôle de zodResolver dans useForm({ resolver: zodResolver(schema) }) ?
2. Pourquoi utilise-t-on Controller pour une Checkbox MUI et pas register() ?
3. Comment valider qu'un champ type="number" est bien reçu comme nombre par Zod (et non comme string) ?
4. Comment afficher un message d'erreur retourné par l'API sur un champ spécifique du formulaire ?

S8 — Travaux Pratiques · 3 exercices
Du schéma au formulaire complet
Chaque exercice est indépendant — commencez par le 1 avant le 2.
1
Formulaire de connexion
Créez un schéma Zod schemaConnexion avec email (email valide, requis) et motDePasse (string, minimum 6 caractères). Construisez le formulaire avec 2 TextField MUI (le second en type="password"), validé par React Hook Form. Affichez les erreurs sous chaque champ. Au submit, affichez un Alert MUI de succès avec l'email saisi. Désactivez le bouton pendant la soumission.
z.string().email() useForm + zodResolver TextField MUI
2
Formulaire de création de compte avec confirmation
Schéma Zod avec nom, email, motDePasse (min 8, au moins un chiffre via regex), confirmerMotDePasse. Utilisez .refine() pour vérifier que les deux mots de passe correspondent — l'erreur doit apparaître sur le champ confirmerMotDePasse. Ajoutez un Select MUI pour le rôle (étudiant / enseignant / admin) et une Checkbox "Accepter les conditions" (obligatoire — validée avec z.literal(true)). Affichez un résumé des données validées sous le formulaire après soumission.
.refine() Controller + Checkbox Select MUI
3
Formulaire d'édition avec chargement et champs conditionnels
Simulez un fetch d'étudiant existant dans un useEffect (setTimeout 1s). Utilisez reset() pour pré-remplir le formulaire une fois les données chargées. Affichez un CircularProgress pendant le chargement. Ajoutez un champ certification (TextField) qui s'affiche uniquement si la filière choisie est "cyber" — utilisez watch('filiere'). Gérez une erreur serveur simulée : si le nom soumis contient "admin", utilisez setError('nom', ...) pour afficher "Ce nom n'est pas autorisé". Sinon, succès.
reset() + useEffect watch() conditionnel setError() serveur