CKTIS / JavaScript
Les événements DOMContentLoaded, hashchange, mouseover et focusin
Choisissez sur quelle cible écouter la disponibilité du DOM, le changement de fragment d’URL, l’entrée du pointeur et la prise de focus. Déléguez les événements des descendants à un conteneur commun.
Version : Current web platform; runtime support varies
Syntaxe
document.addEventListener("DOMContentLoaded", onReady, { once: true });
window.addEventListener("hashchange", onHashChange);
container.addEventListener("mouseover", onMouseOver);
container.addEventListener("focusin", onFocusIn);Ces quatre événements signalent des situations différentes : disponibilité du document, navigation par fragment, déplacement du pointeur et changement de focus. Ils relèvent de la plateforme web. Dans le champ de version, ECMAScript 2024 désigne uniquement le langage JavaScript et ne précise pas la prise en charge de ces événements. Vérifiez leur prise en charge dans les navigateurs visés : un moteur JavaScript seul ne garantit pas la présence du DOM.
Écoutez DOMContentLoaded sur document. Le navigateur émet cet Event non annulable après avoir analysé le HTML et lancé l’exécution des scripts classiques avec defer et des modules sans async. Il n’attend ni les images ni les scripts async ; les feuilles de style peuvent le retarder indirectement en bloquant un script. Si l’initialisation nécessite seulement le DOM analysé, ajoutez un écouteur avec { once: true } lorsque document.readyState === "loading" ; sinon, initialisez immédiatement. L’état "interactive" ne prouve pas que l’événement a déjà été émis.
Écoutez hashchange sur window lorsqu’une navigation modifie le fragment de l’URL dans le même document, par exemple par affectation à location.hash. Le HashChangeEvent fournit les URL complètes dans oldURL et newURL. Appeler history.pushState() ou history.replaceState() ne déclenche pas en soi hashchange, même si le fragment change.
mouseover est un MouseEvent émis sur l’élément où entre le pointeur. Il remonte vers les ancêtres : un déplacement entre descendants peut donc aussi déclencher l’écouteur du conteneur. relatedTarget désigne l’élément quitté, ou vaut null en l’absence de cible secondaire. Pour ne détecter que l’entrée depuis l’extérieur du conteneur, écoutez directement mouseenter, qui ne remonte pas.
focusin est un FocusEvent non annulable émis lorsqu’un élément reçoit le focus, par exemple en appuyant sur Tab. Contrairement à focus, focusin remonte. Pour déléguer focusin ou mouseover dans un arbre DOM ordinaire, utilisez event.target pour identifier l’élément concerné et event.currentTarget pour identifier le conteneur dont l’écouteur s’exécute.
Exemples
(() => {
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,
};
}
})();Résultat
DOMContentLoaded: document=true hashchange: #before -> #after mouseover: button=true, container=true focusin: button=true, container=true
Exécutez le code dans la console du navigateur sur `about:blank`, ou enregistrez-le dans `main.js` et lancez `node main.js`. Le navigateur utilise son DOM natif ; sous Node.js, le code utilise un modèle simplifié de l’arbre et des événements, et non un DOM. `dispatchEvent()` émet des événements synthétiques de façon synchrone : le document n’est pas rechargé, l’URL ne change pas, et ni le pointeur ni le focus ne bougent. Les deux dernières lignes montrent la remontée du bouton vers un conteneur qui n’est pas rattaché au document.
Leçons associées
- JavaScript · Leçon 38 · Avancé · Version : 4
Sources
- 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