Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / JavaScript

Event.target y Event.type

`event.target` identifica el objeto de destino del evento y `event.type` indica su nombre. `event.currentTarget` identifica el objeto donde se registró el listener que se está ejecutando.

Versión: ECMAScript 2024 and the current web platform; runtime support varies

Sintaxis

event.target
event.type

event.target y event.type son propiedades de solo lectura de una instancia de Event. Forman parte de las API de la plataforma web, no de ECMAScript 2024. Su disponibilidad depende del entorno de ejecución.

event.target devuelve el destino del evento tal como lo ve el listener. Es un EventTarget, no necesariamente un Element. En un evento recién creado, su valor es null antes del primer envío. Comprueba que el destino es un elemento antes de llamar a un método propio de los elementos, como closest().

event.currentTarget identifica el objeto donde se registró el listener que se está ejecutando. Si un evento se propaga hacia arriba desde un hijo, target puede ser el hijo y currentTarget el padre. Esta diferencia permite delegar eventos. Fuera de la invocación del listener, currentTarget vale null: guarda ese valor antes de await si vas a necesitarlo después. Al cruzar un límite del Shadow DOM, un listener externo puede ver el elemento anfitrión como destino.

La cadena event.type distingue entre mayúsculas y minúsculas. Usa addEventListener("click", handler), no "onclick": onclick es el nombre de una propiedad de manejo de eventos. Un script también puede crear un evento de tipo "click", así que el tipo por sí solo no demuestra que el usuario haya hecho clic.

Ejemplos

{
  // 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

Pega el bloque en la consola de desarrollo de un navegador. No hace falta hacer clic: con `bubbles: true`, el evento enviado al hijo se propaga hacia arriba y `dispatchEvent()` invoca de forma síncrona el listener del padre. También puedes ejecutar el bloque como archivo `.js` en Node.js 24, donde el ejemplo usa un modelo simplificado de propagación ascendente sin DOM.

Lecciones relacionadas

  • JavaScript · Lección 30 · Avanzado · Versión: 4

Fuentes