CKTIS / JavaScript
Event.target et écouteurs en phase de capture
Distinguez la cible de l’événement de l’objet sur lequel l’écouteur est enregistré, puis voyez comment `capture` détermine l’ordre des appels dans le DOM.
Version : ECMAScript 2024 and the current web platform; runtime support varies
Syntaxe
event.target
event.currentTarget
event.eventPhase
node.addEventListener(type, listener, { capture: true })
node.addEventListener(type, listener, true)
node.addEventListener(type, listener)event.target désigne la cible de l’événement telle que la voit l’écouteur. event.currentTarget désigne l’objet sur lequel l’écouteur en cours d’exécution a été enregistré. Ces deux propriétés sont en lecture seule. En dehors d’un appel à un écouteur, currentTarget vaut null ; conservez donc l’objet pendant l’appel si vous en avez besoin plus tard.
Dans un arbre DOM ordinaire, l’événement parcourt d’abord les ancêtres en direction de la cible. Pendant cette phase (Event.CAPTURING_PHASE, 1), les écouteurs enregistrés avec { capture: true } ou avec true comme troisième argument de addEventListener() sont appelés. Par défaut, capture vaut false.
Sur la cible même, les écouteurs de capture s’exécutent avant les autres, mais les deux groupes lisent la même valeur de event.eventPhase : Event.AT_TARGET (2). Ensuite, seulement si event.bubbles vaut true, l’événement remonte les ancêtres dans l’ordre inverse (Event.BUBBLING_PHASE, 3) et appelle leurs écouteurs sans capture. Désactiver la remontée ne désactive ni la capture ni le traitement sur la cible.
Ces API relèvent du DOM, pas d’ECMAScript. Dans un arbre ordinaire, target reste identique pendant la propagation, mais de l’autre côté d’une frontière du Shadow DOM, il peut désigner l’élément hôte plutôt que le nœud interne.
Exemples
(() => {
// Node.js has no DOM tree. This fallback models only the propagation used here.
class DemoNode {
#parent = null;
#listeners = [];
append(child) {
child.#parent = this;
}
addEventListener(type, listener, options) {
const capture = options === true || options?.capture === true;
this.#listeners.push({ type, listener, capture });
}
dispatchEvent(event) {
const ancestors = [];
for (let node = this.#parent; node !== null; node = node.#parent) {
ancestors.push(node);
}
let currentTarget = null;
let phase = Event.NONE;
Object.defineProperties(event, {
target: { configurable: true, get: () => this },
currentTarget: { configurable: true, get: () => currentTarget },
eventPhase: { configurable: true, get: () => phase }
});
const invoke = (node, nextPhase, capture) => {
currentTarget = node;
phase = nextPhase;
for (const entry of node.#listeners.slice()) {
if (entry.type === event.type && entry.capture === capture) {
entry.listener.call(node, event);
}
}
};
try {
for (let i = ancestors.length - 1; i >= 0; i--) {
invoke(ancestors[i], Event.CAPTURING_PHASE, true);
}
invoke(this, Event.AT_TARGET, true);
invoke(this, Event.AT_TARGET, false);
if (event.bubbles) {
for (const node of ancestors) {
invoke(node, Event.BUBBLING_PHASE, false);
}
}
} finally {
currentTarget = null;
phase = Event.NONE;
}
return !event.defaultPrevented;
}
}
const createElement = (tag) =>
typeof document === 'undefined' ? new DemoNode() : document.createElement(tag);
const parent = createElement('div');
const child = createElement('button');
parent.id = 'parent';
child.id = 'child';
parent.append(child);
const report = (label) => (event) => {
console.log(`${label}: target=${event.target.id}, currentTarget=${event.currentTarget.id}, phase=${event.eventPhase}`);
};
parent.addEventListener('demo', report('parent bubble'));
child.addEventListener('demo', report('child non-capture'));
parent.addEventListener('demo', report('parent capture'), { capture: true });
child.addEventListener('demo', report('child capture'), { capture: true });
child.dispatchEvent(new Event('demo', { bubbles: true }));
})();Résultat
parent capture: target=child, currentTarget=parent, phase=1 child capture: target=child, currentTarget=child, phase=2 child non-capture: target=child, currentTarget=child, phase=2 parent bubble: target=child, currentTarget=parent, phase=3
Exécutez le code dans la console d’un navigateur. Les éléments restent détachés du document et `dispatchEvent()` appelle les écouteurs de façon synchrone. Sous Node.js, le code utilise un modèle simplifié de propagation à la place du DOM du navigateur. Avec `bubbles: false`, seule la dernière ligne disparaît.
Leçons associées
- JavaScript · Leçon 40 · Intermédiaire · Version : 3