CKTIS / JavaScript
Event.target en Event.type
`event.target` geeft het doel van de gebeurtenis aan en `event.type` geeft de naam. `event.currentTarget` geeft aan op welk object de actieve listener is geregistreerd.
Versie: ECMAScript 2024 and the current web platform; runtime support varies
Syntax
event.target
event.typeevent.target en event.type zijn alleen-lezen-eigenschappen van een Event-instantie. Ze behoren tot de API’s van het webplatform, niet tot ECMAScript 2024. De beschikbaarheid hangt af van de uitvoeromgeving.
event.target geeft het doel terug zoals de listener het ziet. Dat is een EventTarget, niet noodzakelijk een Element. Bij een nieuw aangemaakte gebeurtenis is die waarde vóór de eerste verzending null. Controleer of het doel een element is voordat je een elementspecifieke methode zoals closest() aanroept.
event.currentTarget is het object waarop de listener die nu wordt uitgevoerd, is geregistreerd. Wanneer een gebeurtenis vanaf een kindelement omhoog bubbelt, kan target het kind en currentTarget het bovenliggende element zijn. Dat onderscheid maakt gebeurtenisdelegatie mogelijk. Buiten de aanroep van de listener is currentTarget gelijk aan null. Sla de waarde vóór await op als je die later nodig hebt. Wanneer een gebeurtenis een shadow-DOM-grens passeert, kan een listener daarbuiten de shadow-host als doel zien.
event.type is een hoofdlettergevoelige tekenreeks. Gebruik addEventListener("click", handler), niet "onclick": onclick is de naam van een handler-eigenschap. Een script kan ook een gebeurtenis met type "click" maken, dus het type alleen bewijst niet dat een gebruiker heeft geklikt.
Voorbeelden
{
// 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}`);
}Resultaat
before: type=demo, target=null listener: type=demo, targetIsChild=true, currentTargetIsParent=true after: currentTarget=null
Plak het blok in de ontwikkelaarsconsole van een browser. Klikken is niet nodig: door `bubbles: true` bubbelt de naar het kind verzonden gebeurtenis omhoog en roept `dispatchEvent()` de listener op het bovenliggende element synchroon aan. Je kunt het blok ook als `.js`-bestand uitvoeren met Node.js 24. Daar gebruikt het voorbeeld een vereenvoudigd model voor bubbling zonder DOM.
Gerelateerde lessen
- JavaScript · Les 30 · Gevorderd · Versie: 4