Un événement est un signal indiquant que quelque chose s'est produit. Tous les nœuds du DOM génèrent de tels signaux (mais les événements ne sont pas limités au DOM). Voici une liste des événements DOM les plus utiles :
Il y a beaucoup d'autres événements. Nous reviendrons plus en détail sur certains d'entre eux dans les prochains chapitres.
Pour réagir aux événements, nous pouvons assigner un gestionnaire - une fonction qui s'exécute en cas d'événement.
Les gestionnaires sont un moyen d'exécuter du code JavaScript en cas d'actions de l'utilisateur.
Il existe plusieurs façons d'assigner un gestionnaire. Voyons-les, en commençant par la plus simple.
Un gestionnaire peut être défini en HTML à l'aide d'un attribut appelé on<event>.
Par exemple, pour attribuer un gestionnaire de clic à une entrée, nous pouvons utiliser onclick, comme ici :
Au clic de la souris, le code contenu dans onclick s'exécute. Veuillez noter qu'à l'intérieur de onclick, nous utilisons des guillemets simples, car l'attribut lui-même est entre guillemets doubles. Si nous oublions que le code se trouve à l'intérieur de l'attribut et que nous utilisons des guillemets doubles à l'intérieur, comme ceci : onclick="alert("Click !")", cela ne fonctionnera pas correctement.
Un attribut HTML n'est pas un endroit pratique pour écrire beaucoup de code, nous ferions donc mieux de créer une fonction JavaScript et de l'appeler à cet endroit.
Ici, un clic exécute la fonction countRabbits() :
Comme nous le savons, les noms d'attributs HTML ne sont pas sensibles à la casse, donc ONCLICK fonctionne aussi bien que onClick et onCLICK... Mais en général, les attributs sont en minuscules : onclick.
Nous pouvons assigner un gestionnaire à l'aide d'une propriété DOM on<event>.
Par exemple, elem.onclick :
Si le gestionnaire est attribué à l'aide d'un attribut HTML, le navigateur le lit, crée une nouvelle fonction à partir du contenu
de l'attribut et l'écrit dans la propriété DOM.
Cette méthode est donc en fait la même que la précédente.
Ces deux morceaux de code fonctionnent de la même manière :
1. ONLY HTML
1. HTML + JS
Dans le premier exemple, l'attribut HTML est utilisé pour initialiser le bouton.onclick, tandis que dans le second exemple, c'est le script et là toute la différence.
Comme il n'y a qu'une seule propriété onclick, nous ne pouvons pas assigner plus d'un gestionnaire d'événement. Dans l'exemple ci-dessous, l'ajout d'un gestionnaire avec JavaScript écrase le gestionnaire existant :
Pour supprimer un gestionnaire, affectez elem.onclick = null.
La valeur de this à l'intérieur d'un gestionnaire est l'élément. L'élément sur lequel est appliqué le gestionnaire. Dans le code ci-dessous, le bouton affiche son contenu en utilisant this.innerHTML :
Si vous commencez à travailler avec des événements, veuillez noter quelques subtilités. Nous pouvons définir une fonction existante comme gestionnaire :
Mais attention : la fonction doit être assignée comme sayThanks, et non comme sayThanks().
Si nous ajoutons des parenthèses, sayThanks() devient un appel de fonction. La dernière ligne prend donc le résultat de
l'exécution de la fonction, qui est indéfini (puisque la fonction ne renvoie rien), et l'affecte à onclick.
Cela ne fonctionne pas.
...D'un autre côté, dans le balisage, nous avons besoin des parenthèses :
La différence est facile à expliquer. Lorsque le navigateur lit l'attribut, il crée une fonction de traitement avec un corps
à partir du contenu de l'attribut.
C'est donc le balisage qui génère cette propriété :
Un tel appel ne fonctionnera pas :
Attribuer un gestionnaire à elem.onclick, et non à elem.ONCLICK, car les propriétés DOM sont sensibles à la casse.
Le problème fondamental des méthodes d'affectation des gestionnaires d'évènements mentionnés ci-dessus est qu'il est impossible d'affecter
plusieurs gestionnaires à un même événement.
Supposons qu'une partie de notre code veuille mettre en évidence un bouton au moment du clic, et qu'une autre veuille afficher
un message au moment du même clic. Nous aimerions assigner deux gestionnaires d'événements pour cela.
Mais une nouvelle propriété DOM écrasera la propriété existante :
Les développeurs des normes web l'ont compris depuis longtemps et ont proposé une autre façon de gérer les gestionnaires en utilisant les méthodes spéciales addEventListener et removeEventListener qui ne sont pas soumises à une telle contrainte. La syntaxe pour ajouter un gestionnaire :
Ici, event est le nom de l'événement (par exemple, "click" ou "submit").
handler est la fonction à appeler.
options est un objet facultatif qui peut contenir des propriétés supplémentaires pour configurer le comportement.
Propriétés des options:
Pour supprimer un gestionnaire, il faut lui passer exactement la même fonction que celle qui lui a été attribuée.
Ceci ne fonctionne pas :
Le gestionnaire ne sera pas supprimé, car removeEventListener obtient une autre fonction - avec le même code, mais cela n'a pas d'importance, puisqu'il s'agit d'un objet fonction différent. Voici la bonne méthode :
Plusieurs appels à addEventListener permettent d'ajouter plusieurs gestionnaires, comme ceci :
Comme nous pouvons le voir dans l'exemple ci-dessus, nous pouvons définir des gestionnaires à la fois en utilisant une propriété DOM et addEventListener. Mais en général, nous n'utiliserons qu'une seule de ces méthodes.
Il existe des événements qui ne peuvent pas être assignés via une propriété DOM. Seulement avec addEventListener. Par exemple, l'événement DOMContentLoaded, qui se déclenche lorsque le document est chargé et que le DOM a été construit.
Ainsi, addEventListener est plus universel. Toutefois, de tels événements constituent l'exception plutôt que la règle.
Pour gérer correctement un événement, nous devons en savoir plus sur ce qui s'est passé. Pas seulement un "clic" ou
un "enfoncement de touche", mais quelles étaient les coordonnées du pointeur ? Quelle touche a été pressée ? Et ainsi de suite.
Lorsqu'un événement se produit, le navigateur crée un objet événement, y ajoute des détails et le transmet en tant qu'argument
au gestionnaire.
Voici un exemple d'obtention des coordonnées d'un pointeur à partir de l'objet événement :
Quelques propriétés de l'objet événement :
event.type
Type d'événement, ici "click".
event.currentTarget
Elément qui a géré l'événement. C'est exactement la même chose que this, à moins que le gestionnaire soit une fonction
fléchée, ou que son this soit lié à quelque chose d'autre, alors nous pouvons obtenir l'élément à partir de event.currentTarget.
event.clientX / event.clientY
Coordonnées relatives à la fenêtre du curseur, pour les événements de pointeur.
Il existe d'autres propriétés. Beaucoup d'entre elles dépendent du type d'événement : les événements clavier ont un ensemble de
propriétés, les événements pointeur - un autre, nous les étudierons plus tard lorsque nous passerons aux détails des différents
événements.
Si nous attribuons un gestionnaire en HTML, nous pouvons également utiliser l'objet événement, comme ceci :
C'est possible parce que lorsque le navigateur lit l'attribut, il crée un gestionnaire comme celui-ci :
function(event) { alert(event.type) }.
Autrement dit, son premier argument est appelé "event", et le corps est tiré de l'attribut.
Nous pouvons assigner non seulement une fonction, mais aussi un objet comme gestionnaire d'événement en utilisant addEventListener. Lorsqu'un événement se produit, la méthode handleEvent est appelée. Par exemple :
Comme nous pouvons le voir, lorsque addEventListener reçoit un objet comme gestionnaire, il appelle obj.handleEvent(event) en cas d'événement. Nous pourrions également utiliser des objets d'une classe personnalisée, comme ceci :
Ici, le même objet gère les deux événements. Veuillez noter que nous devons explicitement configurer les événements à écouter à l'aide de addEventListener. L'objet menu ne reçoit ici que les événements mousedown et mouseup, et aucun autre type d'événement.
La méthode handleEvent n'est pas obligée de faire tout le travail toute seule. Elle peut appeler d'autres méthodes spécifiques à l'événement à la place, comme ceci :
Maintenant que les gestionnaires d'événements sont clairement séparés, cela peut être plus facile à prendre en charge.
Il existe trois façons d'assigner des gestionnaires d'événements :
Les attributs HTML sont utilisés avec parcimonie, parce que JavaScript au milieu d'une balise HTML a l'air un peu bizarre et
étranger. On ne peut pas non plus y écrire beaucoup de code.
Les propriétés DOM peuvent être utilisées, mais nous ne pouvons pas assigner plus d'un gestionnaire pour un événement
particulier. Dans de nombreux cas, cette limitation n'est pas urgente.
La dernière méthode est la plus flexible, mais c'est aussi la plus longue à écrire. Il y a quelques événements qui ne
fonctionnent qu'avec elle, par exemple transitionend et DOMContentLoaded. De plus, addEventListener supporte
les objets en tant que gestionnaires d'événements. Dans ce cas, la méthode handleEvent est appelée en cas d'événement.
Quelle que soit la manière dont vous assignez le gestionnaire, il reçoit un objet événement comme premier argument.
Cet objet contient les détails de ce qui s'est passé.
Nous en apprendrons plus sur les événements en général et sur les différents types d'événements un peu plus tard.
Ajoutez du JavaScript au bouton pour faire disparaître
Créez un bouton qui se cache lorsqu'on clique dessus. La démo : exo2
Il y a un bouton dans la variable. Il n'y a pas de gestionnaire sur ce bouton. Quels gestionnaires s'exécutent au clic après le code suivant ? Quelles alertes apparaissent ?