WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / JavaScript

Die Ereignisse DOMContentLoaded, hashchange, mouseover und focusin

Wähle das passende Ziel für Listener zur DOM-Bereitschaft, zu URL-Fragmentwechseln, zum Eintritt des Zeigers und zum Fokus. Nutze Bubbling für die Delegation an einen gemeinsamen Container.

Version: 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);

Diese vier Ereignisse melden unterschiedliche Vorgänge: Bereitschaft des Dokuments, Fragmentnavigation, Zeigerbewegung und Fokuswechsel. Sie gehören zur Webplattform. ECMAScript 2024 bezieht sich im Versionsfeld nur auf die Sprache JavaScript und sagt nichts über die Unterstützung dieser Ereignisse aus. Prüfe die Unterstützung in den Zielbrowsern; eine JavaScript-Laufzeit allein stellt kein DOM sicher.

Registriere den Listener für DOMContentLoaded an document. Der Browser löst dieses nicht abbrechbare Event nach dem Parsen des HTML und dem Ausführen klassischer defer-Skripte sowie von Modulskripten ohne async aus. Er wartet nicht auf Bilder oder async-Skripte; Stylesheets können das Ereignis indirekt verzögern, indem sie ein Skript blockieren. Benötigt die Initialisierung nur das geparste DOM, registriere bei document.readyState === "loading" einen Listener mit { once: true }; sonst initialisiere sofort. "interactive" bedeutet nicht zwingend, dass das Ereignis bereits ausgelöst wurde.

Registriere hashchange an window, wenn eine Navigation das URL-Fragment im selben Dokument ändert, etwa durch Zuweisung an location.hash. Das HashChangeEvent enthält in oldURL und newURL vollständige URLs. Ein Aufruf von history.pushState() oder history.replaceState() löst selbst dann kein hashchange aus, wenn sich das Fragment ändert.

mouseover ist ein MouseEvent am Element, das der Zeiger betritt. Es steigt im DOM auf (Bubbling); deshalb kann auch der Wechsel zwischen Nachfahren den Listener des Containers auslösen. relatedTarget ist das verlassene Element oder bei fehlendem zweitem Ziel null. Soll nur der Eintritt von außerhalb des Containers zählen, registriere direkt an ihm mouseenter; dieses Ereignis steigt nicht auf.

focusin ist ein nicht abbrechbares FocusEvent, das beim Erhalt des Fokus ausgelöst wird, etwa beim Drücken von Tab. Anders als focus steigt focusin auf. Bei der Delegation von focusin oder mouseover in einem gewöhnlichen DOM-Baum bezeichnet event.target das betroffene Element und event.currentTarget den Container, dessen Listener gerade läuft.

Beispiele

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

Ergebnis

DOMContentLoaded: document=true
hashchange: #before -> #after
mouseover: button=true, container=true
focusin: button=true, container=true

Führe den Code in der Browserkonsole auf `about:blank` aus oder speichere ihn als `main.js` und starte ihn mit `node main.js`. Der Browser verwendet sein natives DOM; unter Node.js nutzt der Code statt eines DOM ein vereinfachtes Modell des Baums und der Ereignisse. `dispatchEvent()` löst synthetische Ereignisse synchron aus: Es lädt das Dokument nicht neu, ändert die URL nicht und bewegt weder Zeiger noch Fokus. Die letzten beiden Zeilen zeigen, wie Ereignisse vom Button zum nicht mit dem Dokument verbundenen Container aufsteigen.

Zugehörige Lektionen

  • JavaScript · Lektion 38 · Fortgeschritten · Version: 4

Quellen