KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / JavaScript

De gebeurtenissen DOMContentLoaded, pagehide en scroll

Maak onderscheid tussen een gebruiksklare DOM, het verlaten van de pagina en scrollen. Kies het juiste object en houd rekening met herstel uit de bfcache.

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

Syntax

document.addEventListener("DOMContentLoaded", onReady, { once: true });
window.addEventListener("pagehide", onPageHide);
document.addEventListener("scroll", onDocumentScroll);
scrollBox.addEventListener("scroll", onElementScroll);

Deze browsergebeurtenissen beantwoorden drie verschillende vragen: is de DOM klaar voor initialisatie, verlaat de browser dit document en is de scrollpositie veranderd? Ze horen bij het webplatform, niet bij ECMAScript. Ga er buiten een browser niet van uit dat document en window bestaan.

DOMContentLoaded wordt op document afgevuurd nadat de HTML is geparseerd, klassieke scripts met defer zijn uitgevoerd en de browser de evaluatie heeft gestart van de modulescripts zonder async die voor het einde van het parsen zijn ingepland. De gebeurtenis wacht niet tot de asynchrone module-evaluatie klaar is: een await op het hoogste niveau in een afhankelijkheid kan de uitvoering van de code in de importerende module uitstellen tot na de gebeurtenis. Anders dan load wacht het niet op afbeeldingen, ingesloten frames of async-scripts. Een stylesheet kan het indirect vertragen als het een script blokkeert.

Als de initialisatiecode laat kan worden uitgevoerd, controleer dan document.readyState. Bij "loading" registreer je een eenmalige listener voor DOMContentLoaded; anders initialiseer je direct. "interactive" betekent dat het parsen klaar is, niet dat de gebeurtenis al heeft plaatsgevonden of dat andere uitgestelde scripts klaar zijn.

Luister naar pagehide op window als je wilt reageren op het verlaten van het document, niet op alleen een tabbladwissel. Bij deze PageTransitionEvent betekent event.persisted === true dat het document mogelijk uit de terug-/vooruitcache (bfcache) kan worden hersteld, zonder garantie; false betekent dat het niet wordt bewaard voor hergebruik. Hervat het werk bij herstel met pageshow en persisted === true, niet met DOMContentLoaded. pagehide kan uitblijven, bijvoorbeeld als het besturingssysteem een mobiele browser beëindigt. Sla belangrijke gegevens tussentijds op; gebruik visibilitychange en controleer op "hidden" om te zien of een tabblad verborgen wordt.

Luister voor scrollen op de pagina naar scroll op document en lees window.scrollY; luister bij een scrollcontainer op het element zelf en lees zijn scrollTop. Ook scrollen via code kan de gebeurtenis activeren, die niet aangeeft dat het scrollen is gestopt. Houd de handler licht, want gebeurtenissen kunnen snel achter elkaar komen; beperk zo nodig de frequentie van dure updates.

Voorbeelden

(() => {
  const viewportHeight = 80;
  const contentHeight = 240;

  function run(page, doc, createScrollBox) {
    page.addEventListener("pagehide", (event) => {
      console.log(`pagehide: persisted=${event.persisted}`);
    });

    function init() {
      console.log("DOM ready");

      const box = createScrollBox();
      box.addEventListener("scroll", () => {
        console.log(`scroll: ${box.scrollTop}`);
      }, { once: true });

      box.scrollTop = 40;
    }

    if (doc.readyState === "loading") {
      doc.addEventListener("DOMContentLoaded", init, { once: true });
    } else {
      init();
    }
  }

  if (typeof window !== "undefined" && typeof document !== "undefined") {
    run(window, document, () => {
      const box = document.createElement("div");
      box.style.cssText = `width: 200px; height: ${viewportHeight}px; overflow: auto`;

      const content = document.createElement("div");
      content.style.height = `${contentHeight}px`;
      content.textContent = "Scroll demo";
      box.append(content);
      document.body.append(box);
      return box;
    });
    return;
  }

  // Node.js stand-ins exercise the same listeners without a browser DOM.
  class ScrollBox extends EventTarget {
    #offset = 0;

    get scrollTop() {
      return this.#offset;
    }

    set scrollTop(value) {
      const offset = Math.min(Math.max(0, value), contentHeight - viewportHeight);
      if (offset === this.#offset) return;
      this.#offset = offset;
      setTimeout(() => this.dispatchEvent(new Event("scroll")), 0);
    }
  }

  const page = new EventTarget();
  const doc = new EventTarget();
  doc.readyState = "loading";
  run(page, doc, () => new ScrollBox());
  doc.readyState = "interactive";
  doc.dispatchEvent(new Event("DOMContentLoaded"));
})();

Resultaat

DOM ready
scroll: 40

Voer de code één keer uit in de console van een geladen lege HTML-pagina. De initialisatie begint direct en de code laat de container scrollen. Schakel het bewaren van het logboek in en navigeer in hetzelfde tabblad naar een ander document om te kijken of `pagehide: persisted=true` of `pagehide: persisted=false` verschijnt. Die extra regel is niet gegarandeerd. In Node.js voeren vervangende objecten op basis van `EventTarget` dezelfde handlers voor DOM-gereedheid en scrollen uit, zonder het werkelijke browsergedrag te testen.

Gerelateerde lessen

  • JavaScript · Les 45 · Gevorderd · Versie: 4

Bronnen