CKTIS / JavaScript
Event.target et Event.type
`event.target` désigne la cible de l’évènement et `event.type` donne son nom. `event.currentTarget` désigne l’objet sur lequel l’écouteur en cours d’exécution a été enregistré.
Version : ECMAScript 2024 and the current web platform; runtime support varies
Syntaxe
event.target
event.typeevent.target et event.type sont des propriétés d’instance de Event en lecture seule. Elles relèvent des API de la plateforme web, pas d’ECMAScript 2024. Leur disponibilité dépend de l’environnement d’exécution.
event.target donne la cible de l’évènement telle que la voit l’écouteur. C’est un EventTarget, pas nécessairement un Element. Pour un évènement nouvellement créé, cette valeur est null avant le premier déclenchement. Vérifiez que la cible est un élément avant d’appeler une méthode propre aux éléments, comme closest().
event.currentTarget désigne l’objet sur lequel l’écouteur en cours d’exécution a été enregistré. Lorsqu’un évènement remonte depuis un enfant, target peut désigner l’enfant et currentTarget le parent. Cette distinction permet la délégation d’évènements. En dehors de l’appel de l’écouteur, currentTarget vaut null : conservez cette valeur avant await si vous en avez besoin ensuite. Lorsqu’un évènement franchit une limite du DOM fantôme, un écouteur extérieur peut voir l’élément hôte comme cible.
event.type est une chaîne sensible à la casse. Utilisez addEventListener("click", handler), et non "onclick" : onclick est le nom d’une propriété de gestion d’évènement. Un script peut aussi créer un évènement de type "click" ; le type seul ne prouve donc pas qu’une personne a cliqué.
Exemples
{
// Node.js has EventTarget but no DOM tree. Model only the bubbling used here.
const dispatchState = new WeakMap();
class DemoEvent extends Event {
constructor(type, options) {
super(type, options);
dispatchState.set(this, { target: null, currentTarget: null });
}
get target() { return dispatchState.get(this).target; }
get currentTarget() { return dispatchState.get(this).currentTarget; }
}
class DemoNode extends EventTarget {
#parent;
constructor(parent = null) {
super();
this.#parent = parent;
}
dispatchEvent(event) {
const state = dispatchState.get(event);
state.target = this;
try {
for (let node = this; node !== null; node = event.bubbles ? node.#parent : null) {
state.currentTarget = node;
EventTarget.prototype.dispatchEvent.call(node, event);
}
} finally {
state.currentTarget = null;
}
return !event.defaultPrevented;
}
}
const hasDOM = typeof document !== "undefined";
const parent = hasDOM ? document.createElement("div") : new DemoNode();
const child = hasDOM
? parent.appendChild(document.createElement("button"))
: new DemoNode(parent);
const EventClass = hasDOM ? Event : DemoEvent;
const event = new EventClass("demo", { bubbles: true });
console.log(`before: type=${event.type}, target=${event.target}`);
parent.addEventListener("demo", (e) => {
console.log(`listener: type=${e.type}, targetIsChild=${e.target === child}, currentTargetIsParent=${e.currentTarget === parent}`);
});
child.dispatchEvent(event);
console.log(`after: currentTarget=${event.currentTarget}`);
}Résultat
before: type=demo, target=null listener: type=demo, targetIsChild=true, currentTargetIsParent=true after: currentTarget=null
Collez le bloc dans la console de développement d’un navigateur. Aucun clic n’est nécessaire : grâce à `bubbles: true`, l’évènement déclenché sur l’enfant remonte et `dispatchEvent()` appelle l’écouteur du parent de façon synchrone. Vous pouvez aussi exécuter le bloc dans un fichier `.js` avec Node.js 24, où l’exemple utilise un modèle simplifié de la remontée des évènements sans DOM.
Leçons associées
- JavaScript · Leçon 30 · Avancé · Version : 4