Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / JavaScript

Event.target i Event.type

`event.target` wskazuje cel zdarzenia, a `event.type` podaje jego nazwę. `event.currentTarget` wskazuje obiekt, na którym zarejestrowano aktualnie wykonywany nasłuchiwacz.

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

Składnia

event.target
event.type

event.target i event.type to właściwości instancji Event dostępne tylko do odczytu. Należą do interfejsów API platformy webowej, a nie do ECMAScript 2024. Ich dostępność zależy od środowiska wykonawczego.

event.target zwraca cel zdarzenia widoczny dla nasłuchiwacza. Jest to obiekt EventTarget, niekoniecznie Element; przed pierwszym wysłaniem nowego zdarzenia wartość wynosi null. Zanim wywołasz metodę specyficzną dla elementów, taką jak closest(), sprawdź, czy cel jest elementem.

event.currentTarget wskazuje obiekt, na którym zarejestrowano właśnie wykonywany nasłuchiwacz. Gdy zdarzenie propaguje się w górę od elementu potomnego, target może wskazywać dziecko, a currentTarget rodzica. Na tym polega delegowanie zdarzeń. currentTarget ma wartość null poza wykonaniem nasłuchiwacza, więc zapisz tę wartość przed await, jeśli potrzebujesz jej później. Po przekroczeniu granicy Shadow DOM cel widoczny na zewnątrz może zostać zastąpiony elementem hosta.

event.type to tekst, w którym wielkość liter ma znaczenie. Użyj na przykład addEventListener("click", handler), a nie "onclick": onclick to nazwa właściwości procedury obsługi. Skrypt też może utworzyć zdarzenie o typie "click", więc sam typ nie dowodzi, że użytkownik kliknął.

Przykłady

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

Wynik

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

Wklej blok do konsoli deweloperskiej przeglądarki. Niczego nie klikaj: `dispatchEvent()` synchronicznie wywołuje nasłuchiwacz rodzica, ponieważ zdarzenie wysłane do dziecka propaguje się w górę dzięki `bubbles: true`. Możesz też uruchomić blok jako plik `.js` w Node.js 24, gdzie przykład korzysta z uproszczonego modelu propagacji bez DOM.

Powiązane lekcje

  • JavaScript · Lekcja 30 · Zaawansowany · Wersja: 4

Źródła