Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / JavaScript

Gli eventi DOMContentLoaded, hashchange, mouseover e focusin

Scegli dove ascoltare la disponibilità del DOM, le modifiche al frammento dell’URL, l’ingresso del puntatore e il focus. Delega gli eventi dei discendenti a un contenitore comune.

Versione: Current web platform; runtime support varies

Sintassi

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

Questi quattro eventi segnalano situazioni diverse: disponibilità del documento, navigazione tramite frammento, movimento del puntatore e cambiamento del focus. Sono API della piattaforma web. Nel campo della versione, ECMAScript 2024 si riferisce solo al linguaggio JavaScript e non indica se questi eventi sono supportati. Verifica il supporto nei browser di destinazione: un ambiente JavaScript da solo non garantisce la presenza del DOM.

Ascolta DOMContentLoaded su document. Il browser genera questo Event non annullabile dopo aver analizzato l’HTML ed eseguito gli script classici con defer e gli script di tipo modulo senza async. Non attende le immagini né gli script async; i fogli di stile possono ritardarlo indirettamente bloccando uno script. Se l’inizializzazione richiede solo che il DOM sia stato costruito dal parser, registra un listener con { once: true } quando document.readyState === "loading"; altrimenti, inizializza subito. Lo stato "interactive" non prova che l’evento sia già scattato.

Ascolta hashchange su window quando una navigazione cambia il frammento dell’URL nello stesso documento, ad esempio assegnando un valore a location.hash. Il HashChangeEvent contiene gli URL completi in oldURL e newURL. Chiamare history.pushState() o history.replaceState() di per sé non genera hashchange, anche se il frammento cambia.

mouseover è un MouseEvent generato sull’elemento in cui entra il puntatore. Risale verso gli antenati, quindi anche uno spostamento fra discendenti può attivare il listener del contenitore. relatedTarget è l’elemento lasciato dal puntatore, oppure null se non c’è un secondo bersaglio. Per rilevare solo l’ingresso dall’esterno del contenitore, ascolta direttamente mouseenter, che non risale.

focusin è un FocusEvent non annullabile generato quando un elemento riceve il focus, ad esempio premendo Tab. A differenza di focus, focusin risale verso gli antenati. Quando deleghi focusin o mouseover in un normale albero DOM, leggi event.target per identificare l’elemento interessato ed event.currentTarget per identificare il contenitore il cui listener è in esecuzione.

Esempi

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

Risultato

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

Esegui il codice nella console del browser su `about:blank` oppure salvalo come `main.js` ed esegui `node main.js`. Il browser usa il suo DOM nativo; in Node.js il codice usa un modello semplificato dell’albero e degli eventi, non un DOM. `dispatchEvent()` genera eventi sintetici in modo sincrono: non ricarica il documento, non cambia l’URL e non sposta il puntatore né il focus. Le ultime due righe mostrano la propagazione dal pulsante a un contenitore non collegato al documento.

Lezioni correlate

  • JavaScript · Lezione 38 · Avanzato · Versione: 4

Fonti