Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Event.target e Event.type

`event.target` indica il bersaglio dell’evento, mentre `event.type` ne indica il nome. `event.currentTarget` indica l’oggetto su cui è registrato il listener in esecuzione.

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

Sintassi

event.target
event.type

event.target e event.type sono proprietà di sola lettura di un’istanza di Event. Appartengono alle API della piattaforma web, non a ECMAScript 2024. La loro disponibilità dipende dall’ambiente di esecuzione.

event.target restituisce il bersaglio dell’evento così come lo vede il listener. È un EventTarget, non necessariamente un Element; in un evento appena creato vale null prima del primo invio. Verifica che il bersaglio sia un elemento prima di usare un metodo specifico degli elementi come closest().

event.currentTarget indica l’oggetto su cui è stato registrato il listener in esecuzione. Quando un evento risale da un figlio, target può essere il figlio e currentTarget il genitore. Questa distinzione permette la delega degli eventi. Fuori dall’invocazione del listener, currentTarget vale null: salva il valore prima di await se ti servirà in seguito. Quando un evento attraversa un confine dello shadow DOM, un listener esterno può vedere l’elemento host come bersaglio.

event.type è una stringa che distingue maiuscole e minuscole. Usa addEventListener("click", handler), non "onclick": onclick è il nome di una proprietà per il gestore dell’evento. Anche uno script può creare un evento di tipo "click", quindi il tipo da solo non dimostra che l’utente abbia fatto clic.

Esempi

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

Risultato

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

Incolla il blocco nella console di sviluppo del browser. Non serve fare clic: con `bubbles: true` l’evento inviato al figlio risale e `dispatchEvent()` invoca in modo sincrono il listener del genitore. Puoi anche eseguire il blocco come file `.js` con Node.js 24, dove l’esempio usa un modello semplificato della propagazione verso l’alto senza DOM.

Lezioni correlate

  • JavaScript · Lezione 30 · Avanzato · Versione: 4

Fonti