CKTIS / JavaScript
Event.target en listeners in de capturefase
Onderscheid het doel van een gebeurtenis van het object waarop de listener is geregistreerd en zie hoe `capture` de volgorde in de DOM bepaalt.
Versie: ECMAScript 2024 and the current web platform; runtime support varies
Syntax
event.target
event.currentTarget
event.eventPhase
node.addEventListener(type, listener, { capture: true })
node.addEventListener(type, listener, true)
node.addEventListener(type, listener)event.target geeft het doel van de gebeurtenis aan zoals de listener dat ziet. event.currentTarget geeft aan op welk object de actieve listener is geregistreerd. Beide eigenschappen zijn alleen-lezen. Buiten de aanroep van een listener is currentTarget gelijk aan null; bewaar het object dus tijdens de aanroep als je het later nodig hebt.
In een gewone DOM-boom gaat de gebeurtenis eerst via de voorouders naar het doel. In deze fase (Event.CAPTURING_PHASE, 1) worden listeners aangeroepen die zijn geregistreerd met { capture: true } of met true als derde argument van addEventListener(). De standaardwaarde van capture is false.
Op het doel zelf worden capturelisteners vóór listeners zonder capture aangeroepen. Beide groepen zien dezelfde waarde van event.eventPhase: Event.AT_TARGET (2). Alleen als event.bubbles gelijk is aan true, keert de gebeurtenis vervolgens in omgekeerde volgorde langs de voorouders terug (Event.BUBBLING_PHASE, 3) en roept daar de listeners zonder capture aan. Bubbling uitschakelen heeft geen gevolgen voor capture of afhandeling op het doel.
Dit zijn DOM-API’s, geen onderdelen van ECMAScript. In een gewone boom verandert target niet tijdens de propagatie, maar aan de andere kant van een shadow-DOM-grens kan het naar het hostelement verwijzen in plaats van naar de interne node.
Voorbeelden
(() => {
// 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 }));
})();Resultaat
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
Voer de code uit in de browserconsole. De elementen worden niet in het document geplaatst en `dispatchEvent()` roept de listeners synchroon aan. In Node.js gebruikt de code een vereenvoudigd model van gebeurtenispropagatie in plaats van de DOM van de browser. Met `bubbles: false` verdwijnt alleen de laatste regel.
Gerelateerde lessen
- JavaScript · Les 40 · Gemiddeld · Versie: 3