WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / JavaScript

Event.target und Event.type

`event.target` bezeichnet das Ziel des Ereignisses, `event.type` seinen Namen. `event.currentTarget` bezeichnet das Objekt, an dem der gerade ausgeführte Listener registriert wurde.

Version: ECMAScript 2024 and the current web platform; runtime support varies

Syntax

event.target
event.type

event.target und event.type sind schreibgeschützte Eigenschaften einer Event-Instanz. Sie gehören zu den APIs der Webplattform, nicht zu ECMAScript 2024. Ihre Verfügbarkeit hängt von der Laufzeitumgebung ab.

event.target liefert das Ereignisziel aus Sicht des Listeners. Es ist ein EventTarget, nicht unbedingt ein Element. Bei einem neu erzeugten Ereignis ist der Wert vor dem ersten Auslösen null. Prüfe, ob das Ziel ein Element ist, bevor du eine elementspezifische Methode wie closest() aufrufst.

event.currentTarget liefert das Objekt, an dem der gerade ausgeführte Listener registriert wurde. Wenn ein Ereignis von einem Kind nach oben weitergereicht wird, kann target das Kind und currentTarget das Elternelement sein. Darauf beruht die Ereignisdelegation. Außerhalb des Listener-Aufrufs ist currentTarget gleich null. Speichere den Wert vor await, wenn du ihn später brauchst. Überschreitet ein Ereignis eine Shadow-DOM-Grenze, kann ein Listener außerhalb den Shadow-Host als Ziel sehen.

Bei der Zeichenfolge event.type zählt die Groß- und Kleinschreibung. Verwende addEventListener("click", handler), nicht "onclick": onclick ist der Name einer Handler-Eigenschaft. Auch ein Skript kann ein Ereignis des Typs "click" erzeugen. Der Typ allein belegt keinen Klick durch einen Benutzer.

Beispiele

{
  // 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}`);
}

Ergebnis

before: type=demo, target=null
listener: type=demo, targetIsChild=true, currentTargetIsParent=true
after: currentTarget=null

Füge den Block in die Entwicklerkonsole eines Browsers ein. Du musst nichts anklicken: Mit `bubbles: true` steigt das am Kind ausgelöste Ereignis zum Elternelement auf, dessen Listener `dispatchEvent()` synchron aufruft. Du kannst den Block auch als `.js`-Datei mit Node.js 24 ausführen. Dort verwendet das Beispiel ein vereinfachtes Modell der Ereignisausbreitung ohne DOM.

Zugehörige Lektionen

  • JavaScript · Lektion 30 · Fortgeschritten · Version: 4

Quellen