Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / JavaScript

Zdarzenia DOMContentLoaded, hashchange, mouseover i focusin

Dobierz cel nasłuchiwania do gotowości DOM, zmiany fragmentu URL, wejścia wskaźnika lub uzyskania fokusu. Deleguj obsługę zdarzeń potomków na wspólnym kontenerze.

Wersja: Current web platform; runtime support varies

Składnia

document.addEventListener("DOMContentLoaded", onReady, { once: true });
window.addEventListener("hashchange", onHashChange);
container.addEventListener("mouseover", onMouseOver);
container.addEventListener("focusin", onFocusIn);

Te cztery nazwy zdarzeń rozróżniają gotowość dokumentu, nawigację po fragmentach URL, ruch wskaźnika i zmianę fokusu. To interfejsy platformy webowej. W polu wersji ECMAScript 2024 odnosi się wyłącznie do języka JavaScript i nie określa obsługi tych zdarzeń. Sprawdź obsługę w docelowych przeglądarkach; samo środowisko JavaScript nie gwarantuje dostępu do DOM.

Nasłuchuj DOMContentLoaded na document. Przeglądarka wysyła ten nieanulowalny Event po zakończeniu parsowania HTML oraz po uruchomieniu zwykłych skryptów z defer i skryptów modułowych bez async. Nie czeka na obrazy ani skrypty async; arkusze stylów mogą pośrednio opóźnić zdarzenie, blokując skrypt. Jeśli inicjalizacja wymaga tylko sparsowanego DOM, przy document.readyState === "loading" dodaj listener z { once: true }, a w przeciwnym razie uruchom inicjalizację od razu. Stan "interactive" nie dowodzi, że zdarzenie już wystąpiło.

Nasłuchuj hashchange na window, gdy nawigacja zmienia fragment URL w tym samym dokumencie, np. po przypisaniu do location.hash. W HashChangeEvent pola oldURL i newURL zawierają pełne adresy. Wywołania history.pushState() i history.replaceState() same nie wywołują hashchange, nawet gdy zmieniają fragment.

mouseover to MouseEvent wysyłany do elementu, na który wszedł wskaźnik. Zdarzenie bąbelkuje, więc przejście między potomkami również może uruchomić listener kontenera. relatedTarget wskazuje element opuszczony przez wskaźnik lub ma wartość null, jeśli brak powiązanego celu. Aby wykryć tylko wejście z zewnątrz kontenera, nasłuchuj bezpośrednio mouseenter, które nie bąbelkuje.

focusin to nieanulowalny FocusEvent wysyłany, gdy element uzyskuje fokus, np. po naciśnięciu Tab. W przeciwieństwie do focus zdarzenie focusin bąbelkuje. Delegując obsługę focusin lub mouseover w zwykłym drzewie DOM, odczytaj event.target, aby ustalić element docelowy, i event.currentTarget, aby ustalić kontener, na którym działa listener.

Przykłady

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

Wynik

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

Uruchom kod w konsoli przeglądarki w karcie `about:blank` lub zapisz go jako `main.js` i uruchom poleceniem `node main.js`. Przeglądarka korzysta z natywnego DOM, a w Node.js kod korzysta z uproszczonego modelu drzewa i zdarzeń, nie z DOM. `dispatchEvent()` synchronicznie wysyła zdarzenia syntetyczne: nie ładuje ponownie dokumentu, nie zmienia URL, nie przesuwa wskaźnika i nie przenosi fokusu. Dwa ostatnie wiersze pokazują bąbelkowanie z przycisku do kontenera niepodłączonego do dokumentu.

Powiązane lekcje

  • JavaScript · Lekcja 38 · Zaawansowany · Wersja: 4

Źródła