CKTIS / JavaScript
De gebeurtenissen DOMContentLoaded, hashchange, mouseover en focusin
Kies het juiste doel voor listeners die reageren op een gereed DOM, een URL-fragmentwijziging, een binnenkomende aanwijzer of focus. Delegeer gebeurtenissen naar een gedeelde container.
Versie: Current web platform; runtime support varies
Syntax
document.addEventListener("DOMContentLoaded", onReady, { once: true });
window.addEventListener("hashchange", onHashChange);
container.addEventListener("mouseover", onMouseOver);
container.addEventListener("focusin", onFocusIn);Deze vier gebeurtenissen melden verschillende dingen: een gereed document, fragmentnavigatie, beweging van de aanwijzer en een focuswisseling. Het zijn API’s van het webplatform. In het versieveld verwijst ECMAScript 2024 alleen naar de taal JavaScript en zegt het niets over de ondersteuning van deze gebeurtenissen. Controleer de ondersteuning in je doelbrowsers: een JavaScript-runtime alleen garandeert geen DOM.
Luister op document naar DOMContentLoaded. De browser vuurt dit niet-annuleerbare Event af nadat de HTML is geparseerd en klassieke defer-scripts en modulescripts zonder async zijn uitgevoerd. De browser wacht niet op afbeeldingen of async-scripts; stylesheets kunnen de gebeurtenis indirect vertragen door een script te blokkeren. Als initialisatie alleen een geparseerd DOM nodig heeft, registreer je bij document.readyState === "loading" een listener met { once: true }; anders initialiseer je meteen. De status "interactive" bewijst niet dat de gebeurtenis al is afgegaan.
Luister op window naar hashchange wanneer navigatie het URL-fragment binnen hetzelfde document wijzigt, bijvoorbeeld door een waarde aan location.hash toe te kennen. De HashChangeEvent bevat volledige URL’s in oldURL en newURL. Een aanroep van history.pushState() of history.replaceState() vuurt zelf geen hashchange af, zelfs als het fragment verandert.
mouseover is een MouseEvent dat afgaat op het element waar de aanwijzer binnenkomt. De gebeurtenis bubbelt, dus ook beweging tussen afstammelingen kan de listener van de container activeren. relatedTarget is het element dat de aanwijzer heeft verlaten, of null als er geen tweede doel is. Wil je alleen binnenkomst van buiten de container detecteren, luister dan rechtstreeks naar mouseenter, dat niet bubbelt.
focusin is een niet-annuleerbaar FocusEvent dat afgaat wanneer een element focus krijgt, bijvoorbeeld door op Tab te drukken. Anders dan focus bubbelt focusin. Bij delegatie van focusin of mouseover in een gewone DOM-boom geeft event.target het betrokken element aan en event.currentTarget de container waarvan de listener wordt uitgevoerd.
Voorbeelden
(() => {
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,
};
}
})();Resultaat
DOMContentLoaded: document=true hashchange: #before -> #after mouseover: button=true, container=true focusin: button=true, container=true
Voer de code uit in de browserconsole op `about:blank`, of sla de code op als `main.js` en voer `node main.js` uit. De browser gebruikt zijn eigen DOM; in Node.js gebruikt de code een vereenvoudigd model van de boom en de gebeurtenissen, geen DOM. `dispatchEvent()` vuurt synthetische gebeurtenissen synchroon af: het document wordt niet herladen, de URL verandert niet en de aanwijzer en focus verplaatsen zich niet. De laatste twee regels tonen bubbling vanaf de knop naar een container die niet aan het document is gekoppeld.
Gerelateerde lessen
- JavaScript · Les 38 · Gevorderd · Versie: 4
Bronnen
- HTML Standard — The end
- Document: DOMContentLoaded event
- Window: hashchange event
- HTML Standard — The HashChangeEvent interface
- Element: mouseover event
- Element: mouseenter event
- MouseEvent: relatedTarget property
- Element: focusin event
- Element: focus event
- EventTarget: addEventListener() method
- EventTarget: dispatchEvent() method