Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / JavaScript

Event.target a Event.type

`event.target` označuje cieľ udalosti a `event.type` udáva jej názov. `event.currentTarget` označuje objekt, na ktorom je zaregistrovaný práve volaný poslucháč.

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

Syntax

event.target
event.type

event.target a event.type sú vlastnosti inštancie Event určené iba na čítanie. Patria medzi API webovej platformy, nie do ECMAScriptu 2024. Ich dostupnosť závisí od prostredia, v ktorom kód beží.

event.target vracia cieľ udalosti z pohľadu poslucháča. Je to EventTarget, nie nevyhnutne Element. Pri novovytvorenej udalosti má pred prvým odoslaním hodnotu null. Pred volaním metódy určenej pre elementy, napríklad closest(), over, že cieľ je element.

event.currentTarget označuje objekt, na ktorom bol zaregistrovaný práve volaný poslucháč. Keď udalosť prebublá z potomka, target môže označovať potomka a currentTarget rodiča. Tento rozdiel umožňuje delegovanie udalostí. Mimo volania poslucháča má currentTarget hodnotu null. Ak ju potrebuješ neskôr, ulož si hodnotu pred await. Ak udalosť prekročí hranicu shadow DOM, poslucháč mimo neho môže vidieť ako cieľ hostiteľský element.

Reťazec event.type rozlišuje veľké a malé písmená. Použi addEventListener("click", handler), nie "onclick": onclick je názov vlastnosti na obsluhu udalosti. Udalosť typu "click" môže vytvoriť aj skript, takže samotný typ nedokazuje, že používateľ klikol.

Príklady

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

Výsledok

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

Vlož blok do vývojárskej konzoly prehliadača. Nemusíš klikať: vďaka `bubbles: true` udalosť odoslaná potomkovi prebublá k rodičovi a `dispatchEvent()` synchrónne zavolá jeho poslucháča. Blok môžeš spustiť aj ako súbor `.js` v Node.js 24, kde príklad používa zjednodušený model prebublávania bez DOM.

Súvisiace lekcie

  • JavaScript · Lekcia 30 · Pokročilá · Verzia: 4

Zdroje