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

CKTIS / JavaScript

Eventos DOMContentLoaded, pointerover, focusin, pagehide y pageshow

Elige el evento adecuado para la preparación del DOM, la delegación de eventos de puntero y foco, o la navegación y la restauración desde la caché bfcache.

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

Sintaxis

document.addEventListener("DOMContentLoaded", onReady, { once: true });
container.addEventListener("pointerover", onPointerOver);
container.addEventListener("focusin", onFocusIn);
window.addEventListener("pagehide", onPageHide);
window.addEventListener("pageshow", onPageShow);

Registra los manejadores con addEventListener() y respeta las mayúsculas y minúsculas de cada nombre. Estos eventos pertenecen a la plataforma web, no a ECMAScript 2024; su compatibilidad depende del entorno de ejecución.

DOMContentLoaded es un Event no cancelable que se emite en document tras completar el análisis del HTML, ejecutar los scripts clásicos con defer e iniciar la evaluación de los módulos sin async previstos para el final del análisis. Cuando se emite el evento, la evaluación de un módulo puede seguir suspendida en un await de nivel superior. No espera a imágenes, marcos incrustados ni scripts async. Si el código puede arrancar tarde y solo necesita que el DOM esté construido, escucha el evento una sola vez si document.readyState === "loading"; si no, ejecuta el código de inmediato. "interactive" por sí solo no indica que el evento ya se haya emitido.

pointerover (PointerEvent) se emite cuando un puntero entra en la zona de detección de un elemento; en una pantalla táctil, esto puede ocurrir al tocarla. Pasar de un descendiente a otro puede generar más eventos. focusin (FocusEvent) se emite cuando un elemento recibe el foco, por ejemplo mediante el teclado o focus(), y no se puede cancelar. Ambos eventos se propagan hacia los ancestros, a diferencia de pointerenter y focus. Al delegar, event.target identifica el destino y event.currentTarget el contenedor con el manejador.

En window, escucha pagehide al salir de un documento mediante navegación y pageshow tras el load inicial y al restaurar un documento. Ambos son PageTransitionEvent. En pagehide, persisted === true indica que el navegador pretende conservar el documento en la caché de navegación atrás/adelante (bfcache), pero no garantiza su restauración. En pageshow, true indica una restauración desde bfcache sin otro DOMContentLoaded, y false una carga nueva del documento. Al restaurar, reanuda el trabajo sin volver a registrar los manejadores que ya existen.

Cambiar de pestaña no es en sí una navegación y pageshow no demuestra que la página esté visible. Para observar la visibilidad, usa visibilitychange y document.visibilityState. Guarda los datos importantes cuando cambien: pagehide puede no emitirse, por ejemplo si se termina el proceso del navegador móvil.

Ejemplos

(() => {
  const inBrowser = typeof document !== "undefined" && typeof window !== "undefined";

  // Node's EventTarget has no DOM tree. Model just the bubbling used here.
  class DemoNode extends EventTarget {
    #parent = null;

    constructor(localName) {
      super();
      this.localName = localName;
    }

    append(child) {
      child.#parent = this;
    }

    dispatchEvent(event) {
      // Keep the original target while EventTarget supplies currentTarget.
      Object.defineProperty(event, "target", { value: this, configurable: true });
      for (let node = this; node; node = node.#parent) {
        super.dispatchEvent.call(node, event);
        if (!event.bubbles || event.cancelBubble) break;
      }
      return !event.defaultPrevented;
    }
  }

  class DemoPageTransitionEvent extends Event {
    constructor(type, { persisted = false } = {}) {
      super(type);
      this.persisted = Boolean(persisted);
    }
  }

  const doc = inBrowser ? document.implementation.createHTMLDocument() : new DemoNode("#document");
  const page = inBrowser ? window : new EventTarget();
  const Pointer = inBrowser ? window.PointerEvent : Event;
  const Focus = inBrowser ? window.FocusEvent : Event;
  const PageTransition = inBrowser ? window.PageTransitionEvent : DemoPageTransitionEvent;
  const createElement = (name) => inBrowser ? doc.createElement(name) : new DemoNode(name);
  const container = createElement("div");
  const button = createElement("button");
  container.append(button);
  (inBrowser ? doc.body : doc).append(container);

  doc.addEventListener("DOMContentLoaded", (event) => {
    console.log(event.type);
  });
  for (const type of ["pointerover", "focusin"]) {
    container.addEventListener(type, (event) => {
      console.log(`${event.type}: ${event.target.localName} -> ${event.currentTarget.localName}`);
    });
  }
  for (const type of ["pagehide", "pageshow"]) {
    page.addEventListener(type, (event) => {
      console.log(`${event.type}: persisted=${event.persisted}`);
    }, { once: true });
  }

  doc.dispatchEvent(new Event("DOMContentLoaded", { bubbles: true }));
  button.dispatchEvent(new Pointer("pointerover", { bubbles: true }));
  button.dispatchEvent(new Focus("focusin", { bubbles: true }));
  page.dispatchEvent(new PageTransition("pagehide", { persisted: true }));
  page.dispatchEvent(new PageTransition("pageshow", { persisted: true }));
})();

Resultado

DOMContentLoaded
pointerover: button -> div
focusin: button -> div
pagehide: persisted=true
pageshow: persisted=true

El ejemplo emite eventos sintéticos. Muestra la propagación de `button` a `div` y un valor de `persisted` indicado explícitamente; no cambia el foco, no navega ni usa bfcache. En el navegador usa las API nativas y en Node.js un árbol de eventos simplificado.

Lecciones relacionadas

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

Fuentes