CKTIS / JavaScript
Die Ereignisse DOMContentLoaded, pointerover, focusin, pagehide und pageshow
Wähle das passende Ereignis für die DOM-Bereitschaft, die Delegation von Zeiger- und Fokusereignissen oder die Navigation und Wiederherstellung aus dem bfcache.
Version: 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);Registriere Listener mit addEventListener() und achte auf die genaue Groß- und Kleinschreibung. Diese Ereignisse gehören zur Webplattform, nicht zu ECMAScript 2024. Die Unterstützung hängt von der Laufzeitumgebung ab.
DOMContentLoaded ist ein nicht abbrechbares Event an document. Es wird ausgelöst, nachdem das HTML geparst und klassische Skripte mit defer ausgeführt wurden und die Auswertung der für das Ende des Parsens vorgesehenen Modulskripte ohne async begonnen hat. Die Auswertung eines Moduls kann dabei noch an einem await auf oberster Ebene pausieren. Es wartet nicht auf Bilder, eingebettete Frames oder async-Skripte. Kann der Code spät starten und braucht er nur den aufgebauten DOM, registriere bei document.readyState === "loading" einen einmaligen Listener; andernfalls führe ihn sofort aus. "interactive" allein bedeutet nicht, dass das Ereignis schon ausgelöst wurde.
pointerover (PointerEvent) wird ausgelöst, wenn ein Zeiger den Trefferbereich eines Elements erreicht, auf einem Touchscreen auch bei Berührung. Beim Wechsel zwischen Nachfahren können weitere Ereignisse entstehen. focusin (FocusEvent) wird ausgelöst, wenn ein Element den Fokus erhält, etwa per Tastatur oder focus(), und ist nicht abbrechbar. Beide Ereignisse steigen zu Vorfahren auf (Bubbling), anders als pointerenter und focus. Bei der Delegation bezeichnet event.target das Ereignisziel und event.currentTarget den Container mit dem Listener.
Überwache auf window mit pagehide das Verlassen eines Dokuments bei einer Navigation und mit pageshow den Zeitpunkt nach dem ersten load sowie die Wiederherstellung. Beide haben den Typ PageTransitionEvent. Bei pagehide bedeutet persisted === true, dass der Browser das Dokument im Zurück-/Vorwärts-Cache (bfcache) behalten will; die Wiederherstellung ist nicht garantiert. Bei pageshow steht true für eine Wiederherstellung aus dem bfcache ohne erneutes DOMContentLoaded, false für ein neu geladenes Dokument. Setze bei einer Wiederherstellung die Arbeit fort, ohne vorhandene Listener erneut zu registrieren.
Ein bloßer Tabwechsel ist keine Navigation, und pageshow beweist nicht, dass die Seite sichtbar ist. Nutze dafür visibilitychange und document.visibilityState. Speichere wichtige Daten bei Änderungen: pagehide kann ausbleiben, etwa wenn ein mobiler Browser beendet wird.
Beispiele
(() => {
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 }));
})();Ergebnis
DOMContentLoaded pointerover: button -> div focusin: button -> div pagehide: persisted=true pageshow: persisted=true
Das Beispiel löst synthetische Ereignisse aus. Es zeigt das Bubbling von `button` zu `div` und einen ausdrücklich gesetzten `persisted`-Wert; es verschiebt weder den Fokus noch navigiert es oder nutzt den bfcache. Im Browser nutzt es native APIs, in Node.js einen vereinfachten Ereignisbaum.
Zugehörige Lektionen
- JavaScript · Lektion 39 · Fortgeschritten · Version: 4
Quellen
- HTML Standard — The end of parsing
- Document: DOMContentLoaded event
- Element: pointerover event
- Pointer events
- Element: focusin event
- Window: pagehide event
- Window: pageshow event
- HTML Standard — The PageTransitionEvent interface
- Document: visibilitychange event
- EventTarget: dispatchEvent() method
- DOMImplementation: createHTMLDocument() method