Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
JavaScript

La validation des données de formulaires

La validation des données de formulaires. Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre pourquoi valider côté navigateur ET côté serveur ; écrire une règle de validation par cha...

0 chapitres 0 QCM Accès gratuit
Dans cet article

À propos de ce cours

La validation des données de formulaires. Dans cette leçon du cours JavaScript, vous apprendrez à : comprendre pourquoi valider côté navigateur ET côté serveur ; écrire une règle de validation par champ ; afficher des messages clairs et accessibles à côté des champs ; valider au bon moment : sortie du champ, frappe, envoi.

Chapitre 14 — La gestion des formulaires · 14.5 La validation des données de formulaires

🎯 Objectifs de la leçon
• comprendre pourquoi valider côté navigateur ET côté serveur ;
• écrire une règle de validation par champ ;
• afficher des messages clairs et accessibles à côté des champs ;
• valider au bon moment : sortie du champ, frappe, envoi.

Quand valider et pourquoi valider aussi sur le serveur
Figure 1 — Valider dans le navigateur pour le confort, sur le serveur pour la sécurité.

1. Organiser ses règles

Une bonne organisation : un objet regles dont chaque propriété est une fonction qui reçoit la valeur et renvoie un message d'erreur, ou une chaîne vide si tout va bien. Une seule fonction verifier(champ) applique la règle et affiche le message.

📄 l5_validation.html

<!DOCTYPE html>
<html lang="fr">
<head>
  <meta charset="UTF-8">
  <link rel="stylesheet" href="style.css">
</head>
<body>
  <!-- novalidate : on désactive la validation du navigateur pour tout gérer en JavaScript -->
  <form id="contact" novalidate>
    <label>Nom
      <input name="nom" aria-describedby="err-nom">
      <span class="erreur" id="err-nom"></span>
    </label>
    <label>E-mail
      <input name="email" type="email" aria-describedby="err-email">
      <span class="erreur" id="err-email"></span>
    </label>
    <label>Téléphone (Tunisie, 8 chiffres)
      <input name="tel" inputmode="tel" aria-describedby="err-tel">
      <span class="erreur" id="err-tel"></span>
    </label>
    <label>Message
      <textarea name="message" rows="3" aria-describedby="err-message"></textarea>
      <span class="erreur" id="err-message"></span>
    </label>
    <button>Envoyer</button>
  </form>
  <pre id="sortie"></pre>

  <script>
    const form = document.querySelector("#contact");

    // Une règle = une fonction qui renvoie un message d'erreur, ou "" si c'est valide
    const regles = {
      nom: (v) => (v.trim().length < 2 ? "Le nom doit contenir au moins 2 caractères." : ""),
      email: (v) => (!/^[^\s@]+@[^\s@]+\.[a-z]{2,}$/i.test(v.trim()) ? "Adresse e-mail invalide." : ""),
      tel: (v) => (!/^(\+216\s?)?[2-9]\d{7}$/.test(v.replace(/\s/g, "")) ? "8 chiffres, éventuellement précédés de +216." : ""),
      message: (v) => (v.trim().length < 10 ? `Encore ${10 - v.trim().length} caractère(s) minimum.` : ""),
    };

    // Vérifie UN champ et affiche le message à côté
    function verifier(champ) {
      const message = regles[champ.name](champ.value);
      document.querySelector(`#err-${champ.name}`).textContent = message;
      champ.setAttribute("aria-invalid", message ? "true" : "false"); // accessibilité + style
      return message === "";
    }

    // Quand l'utilisateur QUITTE un champ : on vérifie
    form.addEventListener("focusout", (ev) => {
      if (ev.target.name in regles) verifier(ev.target);
    });
    // Pendant la frappe : on ne revérifie qu'un champ déjà signalé en erreur
    form.addEventListener("input", (ev) => {
      if (ev.target.getAttribute("aria-invalid") === "true") verifier(ev.target);
    });

    form.addEventListener("submit", (ev) => {
      ev.preventDefault();
      const champs = Object.keys(regles).map((nom) => form.elements[nom]);
      const resultats = champs.map(verifier);          // on vérifie TOUT (pas de court-circuit)
      const premierInvalide = champs.find((c, i) => !resultats[i]);
      if (premierInvalide) {
        premierInvalide.focus();                       // on amène l'utilisateur à l'erreur
        document.querySelector("#sortie").textContent = `${resultats.filter((r) => !r).length} champ(s) à corriger.`;
        return;
      }
      document.querySelector("#sortie").textContent = "Formulaire valide ✔";
    });
  </script>
</body>
</html>

Envoi avec un nom d'une lettre, un e-mail sans domaine et un message vide : le curseur est placé sur « Nom »
Envoi avec un nom d'une lettre, un e-mail sans domaine et un message vide : le curseur est placé sur « Nom »

2. Les expressions régulières utiles

DonnéeExpressionAccepte
E-mail (simple)/^[^\s@]+@[^\s@]+\.[a-z]{2,}$/iamina@ecole.tn
Téléphone tunisien/^(\+216)?[2-9]\d{7}$/ (espaces retirés)98123456, +21622123456
Code postal tunisien/^\d{4}$/1002
Nom/^[A-Za-zÀ-ÖØ-öø-ÿ' -]{2,40}$/Ben Salah, N'Diaye
Mot de passe solideplusieurs tests : /[a-z]/, /[A-Z]/, /\d/, longueurAbcdefg1

Ne cherchez pas l'expression « parfaite » pour un e-mail : seul l'envoi d'un message de confirmation prouve qu'une adresse existe.

3. De bons messages d'erreur

  • Précis : « 8 chiffres, éventuellement précédés de +216 » plutôt que « Téléphone invalide ».
  • À côté du champ, et reliés à lui par aria-describedby: un lecteur d'écran les lit quand le champ reçoit le focus.
  • Pas trop tôt : ne criez pas « invalide » dès la première lettre. Vérifiez à la sortie du champ, puis en direct seulement pour effacer l'erreur.
  • À l'envoi : vérifiez tout (sans s'arrêter à la première erreur) et placez le curseur sur le premier champ fautif.
  • aria-invalid="true" signale l'erreur aux technologies d'assistance et peut servir de crochet CSS.
ℹ️ À retenir
• Valider dans le navigateur = confort ; sur le serveur = sécurité. Les deux sont indispensables.
• Une règle par champ, qui renvoie un message ou ""; une fonction qui affiche.
• focusout pour vérifier, input pour effacer une erreur, submit pour tout vérifier.
• Messages précis, à côté du champ, avec aria-describedby et aria-invalid.

🛠 Activité 5 — Valider un formulaire de contact

Mission : Ajoutez au formulaire de l'exemple deux champs : « Sujet » (liste obligatoire) et « Code postal » (4 chiffres, facultatif).

Questions pour avancer (répondez dans votre compte rendu, puis appliquez dans votre projet) :

  1. Écrivez les deux nouvelles règles. Comment exprimer « facultatif, mais s'il est rempli, il doit faire 4 chiffres » ?
  2. Testez l'expression du téléphone avec : 98123456, +216 98 123 456, 12345678, 9812345, 0021698123456. Lesquels sont acceptés ? Adaptez-la si nécessaire pour accepter 00216.
  3. Pourquoi l'exemple n'affiche-t-il pas d'erreur pendant que l'on tape pour la première fois ? Que se passerait-il si l'on vérifiait à chaque input dès le départ ?
  4. À l'envoi, l'exemple utilise map puis find au lieu de every. Que se passerait-il avec champs.every(verifier)?
  5. Activez un lecteur d'écran (NVDA, VoiceOver ou l'outil du navigateur), placez-vous sur un champ en erreur : le message est-il lu ? Retirez aria-describedby et recommencez.
  6. Désactivez JavaScript dans le navigateur et envoyez le formulaire. Que se passe-t-il ? Qu'en concluez-vous sur la sécurité ?

Je vérifie / je rends :

  • ☐ Le formulaire complet et le tableau de vos tests de la question 2.

← 14.4 Récupérer toutes les données avec l'objet FormData14.6 La validation de formulaire avec HTML5 →

Cet article vous a-t-il aidé ?