Session du jour
Material UI
Prérequis : JSX · Props

Événements, Formulaires
& Validation avec MUI

Gérer les interactions utilisateur avec les composants Material UI, valider les données d'un formulaire, et découvrir useState en contexte réel.

01
Installer MUI
02
Composants MUI
03
Événements
04
useState rapide
05
Formulaire MUI
06
Validation
07
TP & Quiz
01 — Installation

Installer Material UI dans votre projet

Material UI (MUI) est la bibliothèque de composants React la plus utilisée en entreprise. Elle fournit des composants prêts à l'emploi — boutons, champs, menus — avec le design Google Material.

Étape 1 — Installer les packages
terminalnpm
npm install @mui/material @emotion/react @emotion/styled @mui/icons-material
Ce que chaque package apporte :
explication
@mui/material         → tous les composants (Button, TextField…)
@emotion/react         → moteur CSS-in-JS (requis par MUI)
@emotion/styled        → moteur CSS-in-JS (requis par MUI)
@mui/icons-material    → bibliothèque d'icônes Material
Étape 2 — Configurer dans main.jsx
Envelopper l'application dans le ThemeProvider
main.jsxConfiguration
import React    from 'react';
import ReactDOM from 'react-dom/client';
import { ThemeProvider, createTheme, CssBaseline } from '@mui/material';
import App      from './App';

const theme = createTheme({
  palette: {
    primary: { main: '#1565C0' },  {"← couleur principale"}
  },
});

ReactDOM.createRoot(document.getElementById('root')).render(
  <ThemeProvider theme={theme}>
    <CssBaseline />   {"← reset CSS — toujours l'inclure"}
    <App />
  </ThemeProvider>
);
✓
Vérifier que MUI fonctionne : dans App.jsx, importez et affichez un bouton MUI. Si vous voyez un bouton bleu stylisé, l'installation est réussie.

import { Button } from '@mui/material';
<Button variant="contained">Test MUI</Button>
02 — Composants MUI

Les composants essentiels de MUI

MUI remplace les éléments HTML basiques par des composants React stylisés et accessibles. Voici les composants qu'on utilise pour les formulaires.

TextField
Remplace <input> et <textarea> — label flottant, gestion d'erreurs intégrée
Button
Remplace <button> — variants contained, outlined, text
Select + MenuItem
Remplace <select> — liste déroulante stylisée
Checkbox
Remplace <input type="checkbox"> avec label intégré
Alert
Messages succès, erreur, info, warning — avec icône automatique
CircularProgress
Spinner de chargement pendant une action asynchrone
→
TextField — le composant le plus utilisé
Toutes les props importantes
TextField-demo.jsxTextField
import { TextField } from '@mui/material';

{"// Champ texte de base"}
<TextField
  label="Nom complet"         {"← label flottant"}
  placeholder="Ex: Fatou Diallo"
  variant="outlined"          {"← outlined | filled | standard"}
  fullWidth                    {"← prend toute la largeur"}
/>

{"// Avec erreur affichée"}
<TextField
  label="Email"
  type="email"
  error={true}                 {"← bordure rouge"}
  helperText="Email invalide" {"← message sous le champ"}
  fullWidth
/>

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

{"// Textarea multiligne"}
<TextField
  label="Commentaire"
  multiline
  rows={4}
  fullWidth
/>
→
Button — les variants
contained, outlined, text — chacun a son usage
Button-demo.jsxButton
import { Button } from '@mui/material';

{"// Bouton plein — action principale"}
<Button variant="contained">Envoyer</Button>

{"// Bouton contour — action secondaire"}
<Button variant="outlined">Annuler</Button>

{"// Bouton texte — action tertiaire"}
<Button variant="text">Effacer</Button>

{"// Avec couleur"}
<Button variant="contained" color="error">Supprimer</Button>
<Button variant="contained" color="success">Valider</Button>

{"// Désactivé pendant le chargement"}
<Button variant="contained" disabled={chargement} type="submit">
  {chargement ? 'Envoi...' : 'Envoyer'}
</Button>

{"// Taille"}
<Button size="small" />
<Button size="medium" />  {"← défaut"}
<Button size="large" />
→
Select MUI — liste déroulante
4 composants imbriqués
Select-demo.jsxSelect
import {
  FormControl, InputLabel, Select, MenuItem, FormHelperText
} from '@mui/material';

{"// Structure obligatoire : FormControl > InputLabel + Select > MenuItem"}
<FormControl fullWidth>
  <InputLabel>Filière</InputLabel>
  <Select label="Filière" defaultValue="">
    <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>Choisissez votre filière</FormHelperText>
</FormControl>
Le label= sur Select doit être identique au texte dans InputLabel — sinon le label ne "flotte" pas correctement au-dessus du champ sélectionné.
03 — Événements

Gérer les événements avec MUI

Les composants MUI acceptent les mêmes événements que les éléments HTML — onClick, onChange, onSubmit — mais avec la syntaxe React (camelCase, référence de fonction).

HTML vs React — la différence fondamentale
HTML — attributs string
<!-- ❌ Pas en React -->
<button onclick="handleClick()">
  Cliquer
</button>

<input onchange="handleChange()">
✓ React — camelCase + référence
{"/* ✓ camelCase + référence fn */"}
<Button onClick={handleClick}>
  Cliquer
</Button>

<TextField onChange={handleChange}/>
1
onClick sur Button MUI
Référence de fonction ou fonction fléchée
BoutonMUI.jsxonClick
import { Button } from '@mui/material';

function BoutonsExemples() {

  {"// Handler défini dans le composant"}
  function handleValider() {
    console.log('Bouton validé !');
  }

  function handleAnnuler() {
    console.log('Annulé');
  }

  return (
    <div style={{ display: 'flex', gap: '12px' }}>

      {"// Référence de fonction — recommandé"}
      <Button variant="contained" onClick={handleValider}>
        Valider
      </Button>

      {"// Fonction fléchée inline — pour actions simples"}
      <Button variant="outlined" onClick={() => console.log('Cliqué')}>
        Annuler
      </Button>

      {"// ❌ PIÈGE — ne pas mettre les parenthèses !"}
      {"// onClick={handleValider()} → s'exécute immédiatement"}
      {"// onClick={handleValider}   → s'exécute au clic ✓"}

    </div>
  );
}
2
onChange sur TextField — lire la saisie
event.target.value contient ce que l'user a tapé
ChampLecture.jsxonChange
import { TextField } from '@mui/material';

function ChampLecture() {

  function handleChange(e) {
    {"// e.target.value = ce que l'utilisateur a tapé"}
    console.log('Valeur :', e.target.value);
  }

  return (
    <TextField
      label="Votre nom"
      onChange={handleChange}
      fullWidth
    />
  );
}
À chaque frappe, handleChange est appelé avec l'objet event. e.target.value contient la valeur complète du champ à cet instant. Pour MUI TextField, c'est exactement la même chose qu'un input HTML.
3
onSubmit sur un formulaire avec MUI
e.preventDefault() toujours en premier
FormulaireBase.jsxonSubmit
import { Box, TextField, Button } from '@mui/material';

function FormulaireBase() {

  function handleSubmit(e) {
    e.preventDefault(); {"← toujours en 1er — empêche le rechargement"}

    {"// Lire les valeurs via FormData"}
    const formData = new FormData(e.target);
    const nom   = formData.get('nom');
    const email = formData.get('email');

    console.log({ nom, email });
  }

  return (
    {"// Box component='form' = une div qui se comporte comme un form"}
    <Box
      component="form"
      onSubmit={handleSubmit}
      noValidate            {"← désactive la validation HTML native"}
      sx={{ display: 'flex', flexDirection: 'column', gap: 2 }}
    >
      {"// name= obligatoire pour que FormData puisse lire le champ"}
      <TextField label="Nom"   name="nom"   fullWidth />
      <TextField label="Email" name="email" type="email" fullWidth />

      <Button type="submit" variant="contained" size="large">
        Envoyer
      </Button>
    </Box>
  );
}
Box component="form" est le pattern MUI recommandé. Le sx={{ gap: 2 }} utilise l'espacement MUI (1 = 8px, donc gap:2 = 16px). noValidate désactive la validation HTML native pour qu'on gère nous-mêmes la validation.
04 — useState (preview)

Mémoriser des valeurs avec useState

Pour afficher les erreurs de validation, on a besoin de mémoriser des valeurs qui changent. C'est exactement le rôle de useState — la mémoire d'un composant. On en fait un aperçu rapide aujourd'hui, le chapitre complet vient juste après.

Pourquoi on a besoin de useState ici
❌ Variable ordinaire — ça ne marche pas
function Formulaire() {
  {"// Variable JS ordinaire"}
  let erreur = '';

  function handleSubmit(e) {
    e.preventDefault();
    erreur = 'Champ requis';
    {"// React ne sait pas que ça a changé"}
    {"// → l'écran ne se met PAS à jour"}
  }

  return <p>{erreur}</p>; {"← toujours vide"}
}
✓ useState — React re-affiche
import { useState } from 'react';

function Formulaire() {
  const [erreur, setErreur] = useState('');

  function handleSubmit(e) {
    e.preventDefault();
    setErreur('Champ requis');
    {"// React sait → l'écran se met à jour ✓"}
  }

  return <p>{erreur}</p>; {"← affiche l'erreur"}
}
La syntaxe — 3 éléments
useState-syntaxe.jsxuseState
import { useState } from 'react';

const [valeur, setValeur] = useState('');
{"//       ↑          ↑              ↑"}
{"// ce qu'on lit  pour modifier  valeur initiale"}

{"// Pour les erreurs de formulaire :"}
const [erreurs, setErreurs] = useState({
  nom:   '',
  email: '',
  note:  '',
});

{"// Modifier une valeur → React re-rend le composant"}
setErreurs({ nom: 'Le nom est obligatoire', email: '', note: '' });
💡
L'essentiel à retenir pour aujourd'hui : useState crée une variable que React surveille. Quand on appelle le setter (setErreurs(...)), React re-affiche le composant avec la nouvelle valeur. C'est tout ce dont on a besoin pour afficher les erreurs de validation. Le chapitre complet sur useState vient juste après cette session.
05 — Formulaire MUI

Construire un formulaire complet avec MUI

On assemble maintenant les composants MUI, les événements et useState pour créer un formulaire d'inscription propre et accessible.

→
Formulaire MUI complet — sans validation encore
Architecture propre avant d'ajouter la validation
FormulaireInscription.jsxFormulaire MUI
import {
  Box, TextField, Button, Typography, Stack,
  FormControl, InputLabel, Select, MenuItem,
  FormControlLabel, Checkbox,
} from '@mui/material';

function FormulaireInscription() {

  function handleSubmit(e) {
    e.preventDefault();
    const data = new FormData(e.target);
    console.log({
      nom:      data.get('nom'),
      email:    data.get('email'),
      filiere:  data.get('filiere'),
      note:     data.get('note'),
      boursier: data.get('boursier') === 'on',
    });
  }

  return (
    <Box sx={{ maxWidth: 500, mx: 'auto', p: 3 }}>
      <Typography variant="h5" sx={{ mb: 3, fontWeight: 700 }}>
        Inscription étudiant
      </Typography>

      <Box
        component="form"
        onSubmit={handleSubmit}
        noValidate
      >
        <Stack spacing={2}>

          <TextField
            label="Nom complet"
            name="nom"
            fullWidth
            required
          />

          <TextField
            label="Adresse email"
            name="email"
            type="email"
            fullWidth
            required
          />

          <FormControl fullWidth>
            <InputLabel>Filière</InputLabel>
            <Select name="filiere" label="Filière" defaultValue="">
              <MenuItem value=""><em>Choisir</em></MenuItem>
              <MenuItem value="info">Informatique</MenuItem>
              <MenuItem value="reseaux">Réseaux</MenuItem>
              <MenuItem value="cyber">Cybersécurité</MenuItem>
            </Select>
          </FormControl>

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

          <FormControlLabel
            label="Étudiant boursier"
            control={<Checkbox name="boursier" />}
          />

          <Button
            type="submit"
            variant="contained"
            size="large"
            fullWidth
          >
            S'inscrire
          </Button>

        </Stack>
      </Box>
    </Box>
  );
}
Stack spacing={2} crée automatiquement un espacement de 16px entre chaque enfant. C'est équivalent à mettre margin-bottom: 16px sur chaque élément — mais en moins verbeux.
06 — Validation

Valider les données avec les props MUI

MUI a intégré la gestion des erreurs dans ses composants. Les props error et helperText sur TextField, combinées à useState, permettent une validation propre et visuelle.

Les props d'erreur MUI — error et helperText
error-props.jsxValidation MUI
{"// error={true}    → bordure rouge + label rouge"}
{"// helperText=     → texte sous le champ (en rouge si error=true)"}

<TextField
  label="Nom"
  error={true}                  {"← champ en rouge"}
  helperText="Le nom est obligatoire"
/>

{"// Avec une variable d'erreur :"}
<TextField
  label="Nom"
  error={!!erreurs.nom}          {"← !! convertit string en boolean"}
  helperText={erreurs.nom || ' '} {"← ' ' garde la hauteur même sans erreur"}
/>

{"// !! expliqué :"}
{"// !!'Erreur !'    → !!'...' → !!true  → true  → champ rouge"}
{"// !!''            → !!''   → !!false → false → champ normal"}
→
Formulaire complet avec validation au submit
useState pour les erreurs + props MUI pour l'affichage
FormulaireValide.jsxComplet
import { useState } from 'react';
import {
  Box, TextField, Button, Typography,
  Stack, Alert, FormControl,
  InputLabel, Select, MenuItem,
  FormHelperText,
} from '@mui/material';

function FormulaireValide() {

  {"// État des erreurs — une clé par champ"}
  const [erreurs, setErreurs] = useState({
    nom:     '',
    email:   '',
    filiere: '',
    note:    '',
  });

  {"// État du succès"}
  const [succes, setSucces] = useState(false);

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

    {"// Règles pour le nom"}
    if (!nom.trim()) {
      errs.nom = 'Le nom est obligatoire';
    } else if (nom.trim().length < 2) {
      errs.nom = 'Le nom doit avoir au moins 2 caractères';
    }

    {"// Règles pour l'email"}
    if (!email) {
      errs.email = "L'email est obligatoire";
    } else if (!email.includes('@') || !email.includes('.')) {
      errs.email = 'Format email invalide (ex: nom@domaine.com)';
    }

    {"// Règles pour la filière"}
    if (!filiere) {
      errs.filiere = 'Veuillez choisir une filière';
    }

    {"// Règles pour la note"}
    const noteNum = Number(note);
    if (note === '') {
      errs.note = 'La note est obligatoire';
    } else if (noteNum < 0 || noteNum > 20) {
      errs.note = 'La note doit être entre 0 et 20';
    }

    return errs;
  }

  function handleSubmit(e) {
    e.preventDefault();
    setSucces(false);

    {"// Lire les valeurs"}
    const data    = new FormData(e.target);
    const nom     = data.get('nom')     || '';
    const email   = data.get('email')   || '';
    const filiere = data.get('filiere') || '';
    const note    = data.get('note')    || '';

    {"// Valider"}
    const errs = valider(nom, email, filiere, note);
    setErreurs(errs);

    {"// Vérifier s'il y a des erreurs"}
    const aDesErreurs = Object.values(errs).some(err => err !== '');
    if (aDesErreurs) return; {"← arrêter si erreurs"}

    {"// ✓ Tout est valide"}
    console.log('Données valides :', { nom, email, filiere, note });
    setSucces(true);
    e.target.reset(); {"← vider le formulaire"}
    setErreurs({ nom: '', email: '', filiere: '', note: '' });
  }

  return (
    <Box sx={{ maxWidth: 500, mx: 'auto', p: 3 }}>
      <Typography variant="h5" sx={{ mb: 3, fontWeight: 700 }}>
        Inscription étudiant
      </Typography>

      {succes && (
        <Alert severity="success" sx={{ mb: 2 }}>
          Inscription enregistrée avec succès !
        </Alert>
      )}

      <Box component="form" onSubmit={handleSubmit} noValidate>
        <Stack spacing={2}>

          <TextField
            label="Nom complet"
            name="nom"
            fullWidth
            error={!!erreurs.nom}
            helperText={erreurs.nom || ' '}
          />

          <TextField
            label="Email"
            name="email"
            type="email"
            fullWidth
            error={!!erreurs.email}
            helperText={erreurs.email || ' '}
          />

          <FormControl fullWidth error={!!erreurs.filiere}>
            <InputLabel>Filière</InputLabel>
            <Select name="filiere" label="Filière" defaultValue="">
              <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>
              {erreurs.filiere || ' '}
            </FormHelperText>
          </FormControl>

          <TextField
            label="Note /20"
            name="note"
            type="number"
            inputProps={{ min: 0, max: 20 }}
            fullWidth
            error={!!erreurs.note}
            helperText={erreurs.note || ' '}
          />

          <Button
            type="submit"
            variant="contained"
            size="large"
            fullWidth
          >
            S'inscrire
          </Button>

        </Stack>
      </Box>
    </Box>
  );
}

export default FormulaireValide;
Object.values(errs).some(err => err !== '') vérifie s'il y a au moins une erreur non vide dans l'objet. Si c'est le cas, on arrête le traitement avec return. Le formulaire ne continue que si toutes les erreurs sont vides.
Récapitulatif — règles de validation courantes
ChampRègleCode
NomObligatoire, min 2 car.!nom.trim() puis nom.trim().length < 2
EmailObligatoire, format @!email.includes('@')
Filière (select)Doit être sélectionnée!filiere
Note0 à 20noteNum < 0 || noteNum > 20
Mot de passeMin 6 car.mdp.length < 6
Confirmation mdpIdentiquemdp !== confirmation
07 — Validation & TP

Quiz & Travaux pratiques

4 questions rapides pour valider la session, puis 3 exercices à coder maintenant.

1. Quelle est la différence entre onClick={handleClick} et onClick={handleClick()} ?
2. Pourquoi appeler e.preventDefault() dans onSubmit ?
3. Que fait error={!!erreurs.nom} sur un TextField MUI ?
4. Pourquoi utilise-t-on useState pour les erreurs plutôt qu'une variable ordinaire ?

Session — Travaux Pratiques · 3 exercices
Formulaires MUI avec validation
1
Boutons d'action MUI
Créez un composant PanneBoutons avec 4 Button MUI : "Valider" (contained, vert), "Annuler" (outlined), "Supprimer" (contained, rouge), "Voir plus" (text). Au clic sur chacun, affichez dans la console quel bouton a été cliqué. Ajoutez un état clique (useState, string) qui enregistre le dernier bouton cliqué, et affichez le sous les boutons avec un Alert MUI de couleur adaptée.
2
Formulaire de connexion avec validation MUI
Créez un formulaire de connexion avec 2 TextField MUI (email et motDePasse en type password). Validez au submit : email doit contenir "@" et ".", mot de passe doit avoir au moins 6 caractères. Affichez les erreurs via error et helperText. Si email = "admin@test.sn" et mdp = "123456" → affichez un Alert success "Connexion réussie". Sinon si valide mais mauvais identifiants → Alert error "Identifiants incorrects".
3
Formulaire d'inscription complet
Reproduisez le formulaire de la section 06 avec vos propres règles de validation. Ajoutez un champ telephone (TextField, type tel) avec validation : doit avoir au moins 9 chiffres. Ajoutez un champ promotion (Select) avec les options "L1", "L2", "L3", "M1", "M2". Affichez un Alert success après soumission valide avec un résumé des données saisies. Ajoutez un bouton "Réinitialiser" (outlined) qui vide le formulaire et les erreurs.