Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / JavaScript

Event.target e Event.type

`event.target` identifica o alvo do evento e `event.type` indica o seu nome. `event.currentTarget` identifica o objeto em que foi registado o listener em execução.

Versão: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxe

event.target
event.type

event.target e event.type são propriedades só de leitura de uma instância de Event. Pertencem às APIs da plataforma Web, não ao ECMAScript 2024. A sua disponibilidade depende do ambiente de execução.

event.target devolve o alvo do evento tal como o listener o vê. É um EventTarget, não necessariamente um Element. Num evento acabado de criar, o valor é null antes do primeiro envio. Verifica se o alvo é um elemento antes de chamares um método específico de elementos, como closest().

event.currentTarget identifica o objeto em que foi registado o listener em execução. Quando um evento se propaga de um elemento filho para cima, target pode ser o filho e currentTarget o elemento pai. Esta distinção permite a delegação de eventos. Fora da chamada ao listener, currentTarget vale null: guarda o valor antes de await se precisares dele mais tarde. Se o evento atravessar um limite do shadow DOM, um listener externo pode ver o elemento anfitrião como alvo.

A cadeia event.type distingue maiúsculas de minúsculas. Usa addEventListener("click", handler), não "onclick": onclick é o nome de uma propriedade do gestor do evento. Um script também pode criar um evento do tipo "click", pelo que o tipo, por si só, não prova que o utilizador tenha clicado.

Exemplos

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

Resultado

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

Cola o bloco na consola de programação do navegador. Não é preciso clicar: com `bubbles: true`, o evento enviado ao filho propaga-se para cima e `dispatchEvent()` chama o listener do elemento pai de forma síncrona. Também podes executar o bloco como ficheiro `.js` no Node.js 24, onde o exemplo usa um modelo simplificado da propagação ascendente sem DOM.

Lições relacionadas

  • JavaScript · Lição 30 · Avançado · Versão: 4

Fontes