Web et interaction

Distinguer structure HTML, présentation CSS et comportement JavaScript ; lire une page, suivre un événement et modifier une interaction simple.

Environ 35 minutes

  • Identifier les éléments d’une page HTML
  • Distinguer structure, style et comportement
  • Suivre un événement et sa fonction associée
  • Tester une interaction au clic et au clavier
Sommaire
  1. 1. Décrire le document avec HTML
  2. 2. Séparer présentation et comportement
  3. 3. Associer un événement à une fonction
  4. 4. Modifier une interaction sans perdre sa logique
  5. 5. Tester et expliquer

Un bouton dessiné dans une page accomplit-il forcément une action ?

Une page Web peut présenter du texte, des liens, des champs et des boutons. Leur apparence ne suffit pas à expliquer leur fonctionnement. Il faut distinguer les éléments décrits dans le document, les règles qui déterminent leur présentation et les instructions exécutées lorsqu’un événement survient. Nous étudierons une interaction locale : un clic augmente un compteur affiché. Elle permet de comprendre le rôle du navigateur avant d’aborder, dans le chapitre suivant, les échanges avec un serveur.

1. Décrire le document avec HTML

HTML décrit la structure et le sens du contenu. Un élément est généralement délimité par une balise ouvrante et une balise fermante. <p>Bonjour</p> représente un paragraphe ; <h1>Mes mesures</h1> est un titre principal. Les éléments peuvent être imbriqués. Cette organisation ne se réduit pas à un alignement visuel : elle indique quels contenus appartiennent à une même partie. Un titre reste un titre même si une règle de style lui donne une petite taille.

Un document simple contient un élément html, une partie head pour les informations du document et une partie body pour le contenu de la page. Dans head, title donne notamment le titre de l’onglet ; il ne remplace pas le h1 visible dans body. L’attribut lang de html indique la langue du document. Les liens emploient l’élément a avec un attribut href. Les boutons emploient button. Il est préférable de choisir l’élément qui correspond à l’action plutôt que de donner seulement une apparence de bouton à un paragraphe.

L’arbre représente l’imbrication des éléments, indépendamment de leur position à l’écran.

Le navigateur représente le document chargé par un arbre d’objets appelé DOM. Un programme JavaScript peut retrouver certains de ces objets puis en lire ou modifier des propriétés. L’attribut id sert à identifier un élément de manière unique dans le document. La classe, indiquée par class, peut être partagée par plusieurs éléments pour les regrouper. Confondre ces deux rôles provoque des sélections imprécises : un identifiant répété ne garantit plus que l’on vise l’objet voulu.

Exemple résolu

Dans une page, l’onglet affiche « Jardin », un titre visible affiche « Relevés » et un bouton affiche « Ajouter ». Identifie le rôle des trois éléments correspondants.

  1. Étape 1 : Le texte de l’onglet est fourni par title, placé dans head. Il renseigne le document mais ne constitue pas le titre du contenu visible.
  2. Étape 2 : Le titre principal visible peut être un h1 placé dans body. Il organise la lecture du contenu de la page.
  3. Étape 3 : Le composant d’action est un button. Pour une action locale sans soumission de formulaire, on peut préciser type="button" afin de rendre cette intention explicite.

Résultat : Les trois textes peuvent coexister et remplir des fonctions différentes : métadonnée du document, titre du contenu et commande d’interface.

Piège à éviter : Croire que title est le titre visible de la page confond l’information d’onglet avec la structure du contenu.

À toi d'essayer

Une page possède deux boutons ayant la même classe action. Peut-on leur donner aussi le même id pour les retrouver ? Explique une organisation correcte.

Voir la réponse

La classe action peut être commune, car elle décrit un groupe. Les id doivent être distincts, par exemple ajouter et effacer, afin d’identifier sans ambiguïté chaque bouton.

2. Séparer présentation et comportement

CSS associe des règles de présentation aux éléments sélectionnés. Dans button { color: navy; }, button est le sélecteur ; color est une propriété ; navy est sa valeur. Les accolades délimitent l’ensemble des déclarations. Un sélecteur .action vise les éléments de classe action ; #ajouter vise l’élément d’identifiant ajouter. La couleur d’un bouton peut donc changer sans modifier son sens HTML ni la fonction exécutée lors d’un clic.

La présentation concerne notamment les couleurs, les espacements, les dimensions et la disposition. Le comportement concerne les actions et les modifications de l’état de l’application. Une règle CSS n’effectue pas un calcul de moyenne. Un gestionnaire JavaScript peut calculer cette moyenne puis modifier le texte affiché. Pour lire une page, pose trois questions distinctes : quels objets existent, comment sont-ils présentés et que se passe-t-il lorsqu’on agit ? Cette séparation aide à localiser un défaut.

Une interface doit rester compréhensible sans dépendre seulement d’une couleur. Un bouton doit porter un texte qui annonce son action ; un champ doit être associé à un libellé. Le clavier permet de déplacer le focus et d’activer les composants adaptés. Les éléments HTML natifs fournissent déjà de nombreux comportements utiles. Choisir un vrai bouton facilite donc l’interaction par plusieurs moyens, alors qu’une simple zone colorée exige souvent du code supplémentaire et peut rester inutilisable au clavier.

À toi d'essayer

Le texte d’un bouton est trop clair sur son fond, mais son clic augmente correctement un compteur. Quelle partie de la page faut-il examiner en premier ? Quelle vérification complémentaire est utile ?

Correction détaillée pas à pasDans ce chapitre : 2 corrections détaillées.

3. Associer un événement à une fonction

Un événement signale un fait observé par le navigateur : clic, saisie dans un champ ou soumission d’un formulaire. Une fonction associée à cet événement est un gestionnaire. L’installation du gestionnaire ne signifie pas qu’il a déjà été exécuté. La page est chargée, le programme retrouve le bouton, il enregistre une fonction pour l’événement click, puis cette fonction sera appelée lors d’une activation. Il faut donc distinguer le moment de l’enregistrement et celui de l’action.

La méthode document.getElementById("ajouter") retrouve l’élément possédant cet identifiant. Pour réussir, l’élément doit déjà exister lorsque cette instruction est exécutée. Un script peut être chargé avec defer pour attendre l’analyse du document. Une faute dans l’identifiant peut conduire à ne trouver aucun objet. La console du navigateur permet de repérer ce type d’erreur, mais il faut ensuite vérifier que le bouton et le texte visés sont bien ceux attendus dans la page.

L’activation du bouton déclenche une modification du compteur affiché dans la page.

Exemple résolu

Un bouton d’id ajouter doit augmenter un compteur n initialisé à 0. Un paragraphe d’id valeur affiche ce compteur. Donne le rôle des instructions du gestionnaire.

  1. Étape 1 : Retrouver le bouton après l’analyse du document.const bouton = document.getElementById("ajouter");
  2. Étape 2 : Initialiser l’état une seule fois, hors du gestionnaire.let n = 0;
  3. Étape 3 : Définir une fonction nommée qui augmente n et actualise le texte.function augmenter() { n = n + 1; document.getElementById("valeur").textContent = String(n); }
  4. Étape 4 : Enregistrer la fonction, sans l’appeler immédiatement.bouton.addEventListener("click", augmenter);

Résultat : Après trois activations, n vaut 3 et le paragraphe affiche « 3 ». Le texte initial doit afficher 0 pour être cohérent avec l’état au chargement.

Piège à éviter : Écrire augmenter() à la place de augmenter lors de l’enregistrement appellerait la fonction immédiatement au lieu de transmettre la fonction attendue.

Dans ce programme, n est un nombre tandis que textContent reçoit le texte à afficher. String transforme explicitement le nombre en chaîne. Le gestionnaire modifie l’état puis l’affichage ; si l’une de ces deux étapes manque, le résultat visuel peut rester incorrect. Si l’on réinitialise n à 0 dans la fonction avant chaque augmentation, chaque clic produit 1. Un tableau de trace après chaque activation permet de distinguer ce défaut d’un bouton qui ne déclenche aucune action.

4. Modifier une interaction sans perdre sa logique

Pour adapter un comportement, on commence par son cahier des charges. Si un bouton doit augmenter de 2, il faut changer l’opération sur l’état et vérifier que le libellé annonce désormais cette action. Si un bouton doit remettre le compteur à zéro, son gestionnaire doit affecter 0 puis rafraîchir le texte. Changer seulement le texte affiché laisserait la variable inchangée : au clic suivant sur Ajouter, l’ancienne valeur réapparaîtrait augmentée. L’interface et l’état doivent rester cohérents.

Un clic ne provoque pas obligatoirement un échange réseau. Modifier textContent agit dans le navigateur. Une actualisation complète de la page recrée ici l’état initial, car le programme n’enregistre n dans aucun stockage persistant. Une page peut aussi utiliser un serveur ou un stockage local, mais cette possibilité ne doit pas être supposée à partir de son apparence. Les outils du navigateur permettent d’observer séparément le document, la console et les requêtes réseau.

Exemple résolu

Un compteur vaut 5. Le bouton Remettre à zéro exécute uniquement l’instruction qui affiche "0" dans le paragraphe. Le bouton Ajouter exécute ensuite n = n + 1 et actualise l’affichage. Explique le défaut et corrige la fonction de remise à zéro.

  1. Étape 1 : Après Remettre à zéro, le texte vaut "0" mais la variable n vaut toujours 5 : l’état et l’affichage ne correspondent plus.
  2. Étape 2 : Le clic suivant sur Ajouter calcule 5 + 1 : l’écran affiche alors 6, malgré le zéro affiché juste avant.
  3. Étape 3 : Corriger les deux aspects dans la fonction de remise à zéro.function remettre() { n = 0; document.getElementById("valeur").textContent = "0"; }

Résultat : Après la remise à zéro corrigée, un clic sur Ajouter produit 1 : le nouvel état est bien utilisé.

Piège à éviter : Corriger uniquement le texte masque le problème pendant un instant, mais ne modifie pas la valeur qui servira au calcul suivant.

À toi d'essayer

Un compteur doit augmenter de 2 sans jamais dépasser 10. Il vaut actuellement 9. Propose une règle de mise à jour qui respecte toujours la limite et indique le résultat de deux activations successives.

Correction détaillée pas à pasDans ce chapitre : 2 corrections détaillées.

5. Tester et expliquer

Au bac : lire un programme événementiel

  1. Identifier le composant, son identifiant et l’événement surveillé.
  2. Séparer les instructions exécutées au chargement de celles qui s’exécutent à chaque activation.
  3. Suivre les variables et le texte après plusieurs événements, y compris un cas limite.
  4. Justifier les changements avec le cahier des charges. Si tu poursuis la NSI en terminale, tu réutiliseras ce raisonnement ; aucune épreuve anticipée nationale de NSI n’est supposée ici.
Attention :

Erreurs fréquentes : confondre class et id ; chercher un élément avant qu’il existe ; appeler une fonction au moment où il faut l’enregistrer ; réinitialiser l’état à chaque clic ; modifier le texte sans modifier la variable. Un test après un seul clic peut laisser passer plusieurs de ces erreurs.

Vocabulaire

DOM :
Arbre d’objets représentant le document chargé par le navigateur.
Événement :
Fait signalé au programme, comme une activation ou une saisie.
Gestionnaire :
Fonction associée à un événement.
État :
Valeurs mémorisées dont dépend le comportement courant.

Bilan

QuestionRepère
HTMLDécrit les éléments et leur sens.
CSSDétermine leur présentation.
JavaScriptDécrit notamment leurs réactions aux événements.

Ouvre S’entraîner à l’adresse /exercices. Pour t’exercer, explique une interaction avant de modifier son code, puis vérifie une suite d’actions et une activation au clavier.

À retenir

  • HTML structure le document ; CSS règle sa présentation.
  • Le DOM représente les éléments en mémoire dans le navigateur.
  • Un gestionnaire est exécuté lorsqu’un événement correspondant survient.
  • Une interaction locale peut fonctionner sans requête réseau.
  • L’état et le texte affiché doivent être mis à jour de façon cohérente.

Fiche de révision

Pour lire une interface

objets, apparence, événements, puis valeurs modifiées.

Pour suivre un compteur

écrire une ligne par activation en distinguant variable et affichage.

Pour corriger un bouton

vérifier l’identifiant, le moment d’installation du gestionnaire et le cas limite.

Et maintenant ?

Tu as lu le cours. L’étape suivante tient en une action.

Relis le coursLes exercices de ce chapitre arrivent bientôt.

Prolonge l’expérience !

Continue à explorer ce chapitre à travers de nouvelles activités, des défis et des expériences interactives. Avec Premium, l’apprentissage continue !

Ici, tu débloques aussi 2 corrections détaillées.

Parent ? Suivez les progrès de votre enfant.

Tous les cours de NSI