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.
<!-- En HTML : lowercase, string --> <button onclick="handleClick()"> Cliquer </button> <input onchange="handleChange()" />
{"/* 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.
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.
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> ); }
{"// ❌ 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>
{"// 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> ); }
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…
{"// 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> );
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.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.
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> ))}
{"// React évalue {handleClick(id)}"} {"// → appelle la fonction de suite"} {"// → passe le résultat (undefined)"} {"// à onClick"} <button onClick={handleClick(e.id)} > Supprimer </button>
{"// 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>
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"}
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.
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'"}
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> ); }
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"}
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.
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> ); }
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.
{"// ❌ 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>
function handleSubmit(e) { {"// ❌ Oubli de preventDefault"} {"// La page se recharge !"} const data = new FormData(e.target); console.log(data.get('nom')); }
function handleSubmit(e) { e.preventDefault(); {"// ← 1er ligne"} const data = new FormData(e.target); console.log(data.get('nom')); }
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)"}
| Événement | Sur quel élément | Ce qu'on lit | Quand ça se déclenche |
|---|---|---|---|
onClick | button, div, a… | — (pas de valeur) | Au clic |
onChange | input, select, textarea | e.target.value | À chaque modification |
onChange | input[checkbox] | e.target.checked | À chaque clic sur la case |
onSubmit | form | FormData(e.target) | Au submit (+ toujours preventDefault) |
onKeyDown | input, div… | e.key | À chaque touche pressée |
onFocus | input, select… | — | Quand l'élément prend le focus |
onBlur | input, select… | e.target.value | Quand l'élément perd le focus |
Quiz & Travaux pratiques
4 questions de validation puis 3 exercices pratiques progressifs.
onClick={handleClick} et onClick={handleClick()} ?e.preventDefault() dans un handler onSubmit ?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.
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.
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.