KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

De events DOMContentLoaded, pointerover, focusin, pagehide en pageshow

Kies het juiste event voor een opgebouwd DOM, delegatie van aanwijzer- en focusevents, of navigatie en herstel uit de back/forward-cache.

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

Syntax

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

Registreer listeners met addEventListener() en gebruik de exacte namen, inclusief hoofdletters. Deze events horen bij het webplatform, niet bij ECMAScript 2024; de ondersteuning hangt af van de runtime.

DOMContentLoaded is een niet-annuleerbaar Event op document. Het treedt op nadat de HTML is geparseerd, de klassieke scripts met defer zijn uitgevoerd en de evaluatie is gestart van modulescripts zonder async die voor het einde van het parsen zijn gepland. De evaluatie van een module kan dan nog gepauzeerd zijn bij een await op het hoogste niveau. Het wacht niet op afbeeldingen, ingesloten frames of async-scripts. Kan je code laat starten en heeft die alleen een opgebouwd DOM nodig? Luister dan eenmalig als document.readyState === "loading"; voer de code anders meteen uit. "interactive" alleen betekent niet dat het event al is opgetreden.

pointerover (PointerEvent) treedt op als een aanwijzer het detectiegebied van een element binnenkomt. Op een aanraakscherm kan dat bij aanraking gebeuren. Bewegen tussen afstammelingen kan extra events opleveren. focusin (FocusEvent) treedt op als een element focus krijgt, bijvoorbeeld via het toetsenbord of focus(), en is niet annuleerbaar. Beide events bubbelen naar voorouders, in tegenstelling tot pointerenter en focus. Bij delegatie duidt event.target het doel aan en event.currentTarget de container met de listener.

Luister op window naar pagehide wanneer navigatie het document verlaat en naar pageshow na de eerste load en bij herstel van het document. Beide zijn PageTransitionEvents. Bij pagehide betekent persisted === true dat de browser het document in de back/forward-cache (bfcache) wil bewaren, niet dat herstel gegarandeerd is. Bij pageshow betekent true dat het document uit de bfcache is hersteld zonder nieuwe DOMContentLoaded; false betekent dat het document nieuw is geladen. Hervat bij herstel het werk zonder de bestaande listeners opnieuw te registreren.

Alleen van tabblad wisselen is geen navigatie, en pageshow bewijst niet dat de gebruiker de pagina kan zien. Volg zichtbaarheid met visibilitychange en document.visibilityState. Sla belangrijke gegevens op zodra ze veranderen: pagehide kan uitblijven, bijvoorbeeld als een mobiele browser wordt beëindigd.

Voorbeelden

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

Resultaat

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

Het voorbeeld verstuurt synthetische events. Het laat zien hoe events van `button` naar `div` bubbelen en hoe een expliciete `persisted`-waarde wordt doorgegeven; het verplaatst geen focus, navigeert niet en gebruikt geen bfcache. In een browser gebruikt het de native API’s en in Node.js een vereenvoudigde eventboom.

Gerelateerde lessen

  • JavaScript · Les 39 · Gevorderd · Versie: 4

Bronnen