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.typeevent.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