Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Eventi DOMContentLoaded, pointerover, focusin, pagehide e pageshow

Scegli l’evento adatto per la disponibilità del DOM, la delega degli eventi di puntatore e focus oppure la navigazione e il ripristino dalla bfcache.

Versione: ECMAScript 2024 and the current web platform; runtime support varies

Sintassi

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

Registra i listener con addEventListener(), rispettando maiuscole e minuscole nei nomi. Questi eventi appartengono alla piattaforma web, non a ECMAScript 2024; il supporto dipende dall’ambiente di esecuzione.

DOMContentLoaded è un Event non annullabile emesso su document dopo il completamento dell’analisi dell’HTML, l’esecuzione degli script classici con defer e l’avvio della valutazione dei moduli senza async previsti per la fine dell’analisi. Quando l’evento viene emesso, la valutazione di un modulo può essere ancora sospesa su un await al livello superiore. Non attende immagini, frame incorporati né script async. Se il codice può partire tardi e gli serve solo che il DOM sia stato costruito, ascolta l’evento una sola volta se document.readyState === "loading"; altrimenti esegui subito il codice. "interactive" da solo non indica che l’evento sia già stato emesso.

pointerover (PointerEvent) si verifica quando il puntatore entra nell’area di rilevamento di un elemento; su uno schermo tattile può avvenire al contatto. Spostarsi tra discendenti può generare altri eventi. focusin (FocusEvent) si verifica quando un elemento riceve il focus, ad esempio da tastiera o tramite focus(), e non è annullabile. Entrambi risalgono agli antenati, a differenza di pointerenter e focus. Nella delega, event.target identifica il bersaglio e event.currentTarget il contenitore con il listener.

Su window, ascolta pagehide quando la navigazione lascia il documento e pageshow dopo il load iniziale e al ripristino del documento. Entrambi sono PageTransitionEvent. In pagehide, persisted === true significa che il browser intende conservare il documento nella cache di navigazione avanti/indietro (bfcache), senza garantirne il ripristino. In pageshow, true indica il ripristino dalla bfcache senza un nuovo DOMContentLoaded, mentre false indica un nuovo caricamento del documento. Al ripristino, riprendi il lavoro senza registrare di nuovo i listener già presenti.

Cambiare scheda non è di per sé una navigazione e pageshow non dimostra che la pagina sia visibile. Per osservare la visibilità, usa visibilitychange e document.visibilityState. Salva i dati importanti quando cambiano: pagehide può mancare, ad esempio se il browser su un dispositivo mobile viene terminato.

Esempi

(() => {
  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 }));
})();

Risultato

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

L’esempio emette eventi sintetici. Mostra la propagazione da `button` a `div` e un valore `persisted` impostato esplicitamente; non sposta il focus, non naviga e non usa la bfcache. Nel browser usa le API native, mentre in Node.js usa un albero degli eventi semplificato.

Lezioni correlate

  • JavaScript · Lezione 39 · Avanzato · Versione: 4

Fonti