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

CKTIS / JavaScript

Los eventos DOMContentLoaded, hashchange, mouseover y focusin

Elige dónde escuchar la disponibilidad del DOM, el cambio de fragmento de URL, la entrada del puntero y el foco. Delega los eventos de los descendientes en un contenedor común.

Versión: Current web platform; runtime support varies

Sintaxis

document.addEventListener("DOMContentLoaded", onReady, { once: true });
window.addEventListener("hashchange", onHashChange);
container.addEventListener("mouseover", onMouseOver);
container.addEventListener("focusin", onFocusIn);

Estos cuatro eventos informan de situaciones distintas: disponibilidad del documento, navegación por fragmentos, movimiento del puntero y cambios de foco. Son API de la plataforma web. En el campo de versión, ECMAScript 2024 se refiere solo al lenguaje JavaScript y no indica si se admiten estos eventos. Comprueba su compatibilidad en los navegadores de destino: un entorno JavaScript por sí solo no garantiza que haya DOM.

Escucha DOMContentLoaded en document. El navegador emite este Event no cancelable tras analizar el HTML y ejecutar los scripts clásicos con defer y los módulos sin async. No espera a las imágenes ni a los scripts async; las hojas de estilo pueden retrasarlo indirectamente si bloquean un script. Si la inicialización solo necesita el DOM analizado, registra un listener con { once: true } cuando document.readyState === "loading"; en caso contrario, inicializa de inmediato. El estado "interactive" no prueba que ya se haya emitido el evento.

Escucha hashchange en window cuando una navegación cambie el fragmento de la URL dentro del mismo documento, por ejemplo al asignar un valor a location.hash. HashChangeEvent contiene las URL completas en oldURL y newURL. Llamar a history.pushState() o history.replaceState() no dispara por sí mismo hashchange, aunque cambie el fragmento.

mouseover es un MouseEvent que se emite en el elemento al que entra el puntero. El evento se propaga hacia los ancestros, de modo que moverse entre descendientes también puede activar el listener del contenedor. relatedTarget identifica el elemento que se abandonó, o vale null si no hay un objetivo secundario. Para detectar solo la entrada desde fuera del contenedor, escucha directamente mouseenter, que no se propaga hacia los ancestros.

focusin es un FocusEvent no cancelable que se emite cuando un elemento recibe el foco, por ejemplo al pulsar Tab. A diferencia de focus, focusin se propaga hacia los ancestros. Al delegar focusin o mouseover en un árbol DOM normal, consulta event.target para identificar el elemento afectado y event.currentTarget para identificar el contenedor cuyo listener se está ejecutando.

Ejemplos

(() => {
  const { document, window, HashChangeEvent, MouseEvent, FocusEvent } =
    typeof globalThis.document === "undefined" ? createNodeDemo() : globalThis;

  const container = document.createElement("div");
  const button = document.createElement("button");
  container.append(button);

  document.addEventListener("DOMContentLoaded", (event) => {
    console.log(`${event.type}: document=${event.target === document}`);
  }, { once: true });

  window.addEventListener("hashchange", (event) => {
    console.log(`${event.type}: ${new URL(event.oldURL).hash} -> ${new URL(event.newURL).hash}`);
  }, { once: true });

  for (const type of ["mouseover", "focusin"]) {
    container.addEventListener(type, (event) => {
      console.log(`${event.type}: button=${event.target === button}, container=${event.currentTarget === container}`);
    });
  }

  document.dispatchEvent(new Event("DOMContentLoaded", { bubbles: true }));
  window.dispatchEvent(new HashChangeEvent("hashchange", {
    oldURL: "https://example.com/#before",
    newURL: "https://example.com/#after",
  }));
  button.dispatchEvent(new MouseEvent("mouseover", { bubbles: true }));
  button.dispatchEvent(new FocusEvent("focusin", { bubbles: true }));

  // Node.js fallback: model only the detached tree and event data used here.
  function createNodeDemo() {
    class DemoElement extends EventTarget {
      parentNode = null;

      append(child) {
        child.parentNode = this;
      }

      dispatchEvent(event) {
        let current = this;
        Object.defineProperties(event, {
          target: { configurable: true, value: this },
          currentTarget: { configurable: true, get: () => current },
        });

        try {
          for (; current; current = current.parentNode) {
            EventTarget.prototype.dispatchEvent.call(current, event);
            if (!event.bubbles || event.cancelBubble) break;
          }
        } finally {
          current = null;
        }
        return !event.defaultPrevented;
      }
    }

    class DemoHashChangeEvent extends Event {
      constructor(type, { oldURL, newURL }) {
        super(type);
        this.oldURL = oldURL;
        this.newURL = newURL;
      }
    }

    return {
      document: Object.assign(new EventTarget(), {
        createElement: () => new DemoElement(),
      }),
      window: new EventTarget(),
      HashChangeEvent: DemoHashChangeEvent,
      MouseEvent: Event,
      FocusEvent: Event,
    };
  }
})();

Resultado

DOMContentLoaded: document=true
hashchange: #before -> #after
mouseover: button=true, container=true
focusin: button=true, container=true

Ejecuta el código en la consola del navegador en `about:blank`, o guárdalo como `main.js` y ejecuta `node main.js`. El navegador usa su DOM nativo; en Node.js el código usa un modelo simplificado del árbol y de los eventos, no un DOM. `dispatchEvent()` emite eventos sintéticos de forma síncrona: no recarga el documento, cambia la URL, mueve el puntero ni desplaza el foco. Las dos últimas líneas muestran la propagación desde el botón hasta un contenedor que no está conectado al documento.

Lecciones relacionadas

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

Fuentes