Semaine 5 · React Débutants

Gérer les
Événements

Réagir aux actions de l'utilisateur : clics, saisie, soumission. Comprendre l'objet event, passer des arguments, et lire un formulaire sans état.

onClick, onChange, onSubmit
L'objet event
Passer des arguments
Formulaires sans state
Prérequis : S1 JSX · S2 Props · S3 Conditionnel · S4 Listes
01 — Concept

React et les événements

Un événement, c'est une action qui se produit dans l'interface : l'utilisateur clique, tape du texte, soumet un formulaire… React écoute ces actions et déclenche des fonctions en réponse.

HTML vs React — la différence de syntaxe
Les événements s'écrivent différemment en React
HTML classique
<!-- En HTML : lowercase, string -->
<button onclick="handleClick()">
  Cliquer
</button>

<input onchange="handleChange()" />
React (JSX)
{"/* En React : camelCase, référence fn */"}
<button onClick={handleClick}>
  Cliquer
</button>

<input onChange={handleChange} />

En React : noms en camelCase (onClick pas onclick) et on passe une référence de fonction, pas une string ni un appel.

🖱️
onClick
Clic souris / tap
Boutons, liens, cartes cliquables, icônes d'action
⌨️
onChange
Saisie dans un champ
Inputs texte, select, checkbox, textarea
📤
onSubmit
Soumission formulaire
Formulaires — déclenché par le bouton submit ou Entrée
🖱️
onMouseEnter
Survol souris
Tooltips, menus au survol, effets hover en JS
🎯
onFocus / onBlur
Focus / perte focus
Validation à la sortie d'un champ, mise en avant
⌨️
onKeyDown
Touche pressée
Raccourcis clavier, Entrée pour valider, Echap pour fermer
💡
Ce chapitre couvre onClick, onChange et onSubmit — les trois événements que vous utiliserez dans 90 % de vos composants. Les autres suivent la même logique une fois ces trois maîtrisés.
02 — onClick

Réagir à un clic avec onClick

onClick est l'événement le plus courant. On lui passe une référence vers une fonction — appelée "gestionnaire d'événement" ou "handler". Cette fonction est exécutée au moment du clic.

1
Définir et passer le handler — la bonne façon
Référence de fonction, pas appel de fonction
Bouton.jsxonClick basique
function Bouton() {

  {"// Le handler : une fonction ordinaire définie dans le composant"}
  function handleClick() {
    console.log('Bouton cliqué !');
  }

  return (
    {"// On passe la RÉFÉRENCE de la fonction (sans parenthèses)"}
    <button onClick={handleClick}>
      Cliquer ici
    </button>
  );
}
Le handler peut aussi être une fonction fléchée inline : onClick={() => console.log('clic')} — utile pour des actions simples.
🚨
Le piège numéro 1 : appeler la fonction au lieu de la passer.
piège.jsxAttention !
{"// ❌ MAUVAIS — handleClick() est appelé immédiatement au rendu !"}
<button onClick={handleClick()}>Clic</button>

{"// ✓ CORRECT — on passe la référence, React l'appellera au clic"}
<button onClick={handleClick}>Clic</button>

{"// ✓ CORRECT aussi — fonction fléchée pour les actions simples"}
<button onClick={() => console.log('clic')}>Clic</button>
2
Passer le handler via props
Un parent contrôle le comportement de l'enfant
BoutonAction.jsxhandler en prop
{"// Composant enfant — reçoit le handler en prop"}
function BoutonAction({ texte, onClick }) {
  return (
    <button onClick={onClick}>
      {texte}
    </button>
  );
}

{"// Composant parent — définit ce qui se passe"}
function App() {

  function handleValider() {
    console.log('Formulaire validé !');
  }

  function handleAnnuler() {
    console.log('Action annulée.');
  }

  return (
    <div>
      <BoutonAction texte="Valider"  onClick={handleValider} />
      <BoutonAction texte="Annuler"  onClick={handleAnnuler} />
    </div>
  );
}
Par convention, on nomme les handlers "handle + action" (handleClick, handleSubmit, handleDelete…) et les props d'événement "on + action" (onClick, onDelete, onClose…).
03 — L'objet event

Lire les informations de l'événement

React passe automatiquement un objet event (souvent abrégé e) à chaque handler. Cet objet contient toutes les informations sur ce qui vient de se passer : quelle touche, quel élément, quelle valeur…

L'objet event — propriétés essentielles
Ce qu'on utilise le plus souvent
// event — les propriétés clés
event.target
L'élément HTML qui a déclenché l'événement
Element
event.target.value
La valeur actuelle d'un input / select
string
event.target.checked
État coché d'une checkbox
boolean
event.key
'Enter', 'Escape', 'ArrowUp'…
string
event.preventDefault()
Annule le comportement par défaut du navigateur
function
event.stopPropagation()
Empêche l'événement de remonter au parent
function
→
Utiliser event dans un handler
React le passe automatiquement en premier argument
exemples-event.jsxevent
{"// React passe 'event' automatiquement — on le nomme 'e' par convention"}

{"// 1. Lire la touche pressée"}
function handleKeyDown(e) {
  if (e.key === 'Enter') {
    console.log('Entrée pressée !');
  }
  if (e.key === 'Escape') {
    console.log('Echap pressée, fermer la modal');
  }
}

{"// 2. Lire la valeur d'un input"}
function handleChange(e) {
  console.log(e.target.value); {"// ce que l'utilisateur a tapé"}
}

{"// 3. Empêcher le rechargement de page d'un formulaire"}
function handleSubmit(e) {
  e.preventDefault(); {"// indispensable sur les formulaires !"}
  console.log('Formulaire soumis sans rechargement');
}

{"// Utilisation dans le JSX"}
return (
  <div>
    <input onKeyDown={handleKeyDown} onChange={handleChange} />
    <form onSubmit={handleSubmit}>...</form>
  </div>
);
Par convention, l'objet event est nommé "e" ou "event". "e" est plus court et plus répandu dans la communauté React.
💡
event.target vs event.currentTarget : target est l'élément exact qui a reçu le clic (peut être un enfant). currentTarget est toujours l'élément sur lequel le handler est défini. Pour lire la valeur d'un input, utilisez toujours event.target.value.
04 — Passer des arguments

Handlers avec arguments personnalisés

Parfois on veut passer des données supplémentaires au handler — par exemple l'id de l'élément sur lequel on clique. Il faut alors envelopper le handler dans une fonction fléchée.

Le problème — handler dans un .map()
Comment savoir sur quel élément l'utilisateur a cliqué ?
problème.jsxContexte
const etudiants = [
  { id: 1, nom: 'Fatou' },
  { id: 2, nom: 'Moussa' },
  { id: 3, nom: 'Aminata' },
];

function handleSupprimer(id) {
  console.log(`Supprimer étudiant id=${id}`);
}

{"// On veut passer l'id de chaque étudiant au click"}
{etudiants.map((e) => (
  <div key={e.id}>
    {e.nom}

    {"// ❌ MAUVAIS — appelle handleSupprimer immédiatement !"}
    <button onClick={handleSupprimer(e.id)}>Supprimer</button>

    {"// ✓ CORRECT — envelopper dans une fonction fléchée"}
    <button onClick={() => handleSupprimer(e.id)}>Supprimer</button>
  </div>
))}
✗ Sans wrapper — s'appelle au rendu
{"// React évalue {handleClick(id)}"}
{"// → appelle la fonction de suite"}
{"// → passe le résultat (undefined)"}
{"//   à onClick"}
<button
  onClick={handleClick(e.id)}
>
  Supprimer
</button>
✓ Avec wrapper — s'appelle au clic
{"// onClick reçoit une nouvelle fonction"}
{"// React l'appelle quand l'user clique"}
{"// → handleClick(e.id) s'exécute"}
{"//   seulement à ce moment-là"}
<button
  onClick={() => handleClick(e.id)}
>
  Supprimer
</button>
Combiner event et arguments
Passer un argument ET conserver l'objet event
event-et-arg.jsxcombiné
function handleAction(id, e) {
  e.preventDefault();
  console.log(`Action sur id=${id}`);
}

{"// Dans le JSX — on passe id ET l'event"}
<button onClick={(e) => handleAction(etudiant.id, e)}>
  Action
</button>

{"// La fonction fléchée reçoit e automatiquement de React"}
{"// et le transmet à handleAction"}
05 — onChange

Lire la saisie avec onChange

onChange se déclenche à chaque frappe dans un champ texte, à chaque sélection dans un select, à chaque clic sur une checkbox. On l'utilise pour lire en temps réel ce que l'utilisateur saisit.

1
onChange sur un input texte
Lire event.target.value à chaque frappe
ChampTexte.jsxonChange texte
function ChampTexte() {

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

  return (
    <div>
      <label>Votre nom</label>
      <input
        type="text"
        placeholder="Entrez votre nom"
        onChange={handleChange}
      />
    </div>
  );
}
{"// À chaque frappe → handleChange est appelé"}
{"// 'F' → 'Fa' → 'Fat' → 'Fato' → 'Fatou'"}
Sans useState, onChange permet juste de lire la valeur. Pour mémoriser la valeur et re-afficher quelque chose, il faudra useState — c'est le sujet de S6.
2
onChange sur un select
Même principe — event.target.value donne l'option choisie
SelectFiliere.jsxonChange select
function SelectFiliere() {

  function handleChange(e) {
    console.log('Filière choisie :', e.target.value);
  }

  return (
    <select onChange={handleChange}>
      <option value="">-- Choisir une filière --</option>
      <option value="info">Informatique</option>
      <option value="reseaux">Réseaux</option>
      <option value="cyber">Cybersécurité</option>
    </select>
  );
}
Pour un select, event.target.value retourne la valeur de l'attribut value de l'option sélectionnée.
3
onChange sur une checkbox
Utiliser event.target.checked, pas value
Checkbox.jsxonChange checkbox
function OptionBoursier() {

  function handleChange(e) {
    {"// Pour une checkbox → .checked (booléen), pas .value"}
    console.log('Boursier coché :', e.target.checked);
  }

  return (
    <label>
      <input
        type="checkbox"
        onChange={handleChange}
      />
      Étudiant boursier
    </label>
  );
}
{"// Cocher   → handleChange appelé → e.target.checked = true"}
{"// Décocher → handleChange appelé → e.target.checked = false"}
Checkbox : utiliser event.target.checked (boolean). Input texte, select, textarea : utiliser event.target.value (string). Ne pas confondre les deux.
06 — onSubmit

Soumettre un formulaire avec onSubmit

onSubmit se déclenche quand l'utilisateur soumet le formulaire — en cliquant un bouton de type submit ou en appuyant sur Entrée. La première chose à faire est toujours d'appeler event.preventDefault() pour empêcher le rechargement de page.

🚨
e.preventDefault() est obligatoire sur les formulaires. Par défaut, la soumission d'un formulaire HTML recharge la page. En React, on veut intercepter l'événement et gérer nous-mêmes ce qui se passe.
→
Lire un formulaire complet à la soumission
Utiliser FormData ou les refs pour lire tous les champs d'un coup
FormulaireInscription.jsxonSubmit complet
function FormulaireInscription() {

  function handleSubmit(e) {
    e.preventDefault(); {"// 1. Bloquer le rechargement — TOUJOURS en premier"}

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

    {"// 3. Utiliser les données"}
    console.log({ nom, email, filiere });
    {"// → { nom: 'Fatou', email: 'fatou@..', filiere: 'info' }"}
  }

  return (
    <form onSubmit={handleSubmit}>

      <div>
        <label>Nom</label>
        <input type="text" name="nom" required />
      </div>

      <div>
        <label>Email</label>
        <input type="email" name="email" required />
      </div>

      <div>
        <label>Filière</label>
        <select name="filiere">
          <option value="info">Informatique</option>
          <option value="reseaux">Réseaux</option>
        </select>
      </div>

      <button type="submit">S'inscrire</button>

    </form>
  );
}
L'attribut "name" sur chaque input est indispensable pour FormData.get(). Sans name, FormData ne peut pas identifier le champ. Le bouton doit être de type="submit" (c'est la valeur par défaut si non précisé).
💡
FormData sans useState — parfaitement valide. Pour des formulaires simples où on n'a pas besoin d'afficher la valeur en temps réel, FormData à la soumission est une approche propre et suffisante. On verra les formulaires contrôlés avec useState en S8.
07 — Pièges & bonnes pratiques

Les erreurs classiques à éviter

Les événements concentrent plusieurs pièges fréquents que tous les débutants rencontrent. Les identifier permet de gagner beaucoup de temps de débogage.

Piège 1 — Appeler vs référencer
Le piège le plus courant en React
piège-1.jsx
{"// ❌ handleClick() s'exécute au rendu, pas au clic"}
<button onClick={handleClick()}>Clic</button>

{"// ✓ handleClick sera appelé par React au moment du clic"}
<button onClick={handleClick}>Clic</button>

{"// ✓ Avec argument — wrapper obligatoire"}
<button onClick={() => handleClick(id)}>Clic>
Piège 2 — Oublier preventDefault sur un formulaire
Sans preventDefault, la page se recharge et tout est perdu
✗ Page recharge au submit
function handleSubmit(e) {
  {"// ❌ Oubli de preventDefault"}
  {"// La page se recharge !"}
  const data = new FormData(e.target);
  console.log(data.get('nom'));
}
✓ Toujours en premier
function handleSubmit(e) {
  e.preventDefault(); {"// ← 1er ligne"}

  const data = new FormData(e.target);
  console.log(data.get('nom'));
}
Piège 3 — .checked vs .value sur une checkbox
Lire la mauvaise propriété de event.target
piège-3.jsx
function handleChange(e) {
  {"// ❌ Sur une checkbox, .value retourne toujours 'on' — inutile"}
  console.log(e.target.value);   {"// → 'on' (toujours)"}

  {"// ✓ Sur une checkbox, utiliser .checked"}
  console.log(e.target.checked);  {"// → true ou false"}
}

{"// Résumé rapide :"}
{"// input[type=text]   → event.target.value    (string)"}
{"// input[type=email]  → event.target.value    (string)"}
{"// select             → event.target.value    (string)"}
{"// textarea           → event.target.value    (string)"}
{"// input[type=checkbox] → event.target.checked (boolean)"}

Récapitulatif — tout en un coup d'œil
ÉvénementSur quel élémentCe qu'on litQuand ça se déclenche
onClickbutton, div, a…— (pas de valeur)Au clic
onChangeinput, select, textareae.target.valueÀ chaque modification
onChangeinput[checkbox]e.target.checkedÀ chaque clic sur la case
onSubmitformFormData(e.target)Au submit (+ toujours preventDefault)
onKeyDowninput, div…e.keyÀ chaque touche pressée
onFocusinput, select…—Quand l'élément prend le focus
onBlurinput, select…e.target.valueQuand l'élément perd le focus
08 — Validation

Quiz & Travaux pratiques

4 questions de validation puis 3 exercices pratiques progressifs.

1. Quelle est la différence entre onClick={handleClick} et onClick={handleClick()} ?
2. Comment passer l'id d'un étudiant à un handler dans un .map() ?
3. Pourquoi appeler e.preventDefault() dans un handler onSubmit ?
4. Pour lire si une checkbox est cochée, quelle propriété utilise-t-on ?

S5 — Travaux Pratiques · 3 exercices
Interactivité sans état
1
Boutons d'action sur une liste
Reprenez le tableau de 5 étudiants du TP de S4. Ajoutez dans chaque CarteEtudiant un bouton "Voir détails" et un bouton "Signaler". Au clic sur "Voir détails" : affichez dans la console le nom et la note de l'étudiant. Au clic sur "Signaler" : affichez Étudiant [nom] signalé. Passez les handlers depuis App via props. Utilisez des fonctions fléchées inline pour passer l'id ou le nom.
2
Champ de recherche avec onChange
Créez un composant BarreRecherche avec un input et un select (filière). Sur chaque onChange, affichez dans la console la valeur actuelle du champ modifié avec son label : Recherche : "Fatou" ou Filière : "info". Ajoutez un bouton "Effacer" avec onClick qui fait console.log('Champs effacés'). Pas de useState pour l'instant.
3
Formulaire d'inscription complet
Créez un composant FormulaireEtudiant avec les champs : nom (texte, requis), email (email, requis), filiere (select avec 3 options), boursier (checkbox), note (number, min=0, max=20). À la soumission (onSubmit) : appeler e.preventDefault(), lire tous les champs avec FormData, et afficher l'objet complet dans la console incluant boursier converti en booléen. Affichez un message "Formulaire soumis !" dans la console en fin de handler.