mitmario.dev

Sichtbarkeit beobachten

JavaScript Im Browser 4 Min Lesezeit 3 BeispieleLektion 3 von 6

Ein Bild soll erst laden, wenn es ins Bild kommt. Eine Animation soll erst starten, wenn jemand hinsieht, und die nächste Seite einer Liste erst kommen, wenn das Ende der jetzigen erreicht ist. Alle drei hängen an derselben Frage, nämlich ob ein Element gerade zu sehen ist.

Warum nicht mit einem Scroll-Listener

Der teure Weg mit einem Scroll-Listener
const fenster = document.getElementById("fenster");
const zaehlung = document.getElementById("zaehlung");
const abschnitte = document.querySelectorAll(".abschnitt");

let laeufe = 0;
let rechnungen = 0;

fenster.addEventListener(
  "scroll",
  () => {
    laeufe = laeufe + 1;
    const kasten = fenster.getBoundingClientRect();

    for (const abschnitt of abschnitte) {
      rechnungen = rechnungen + 1;
      const eigener = abschnitt.getBoundingClientRect();
      const sichtbar = eigener.bottom > kasten.top && eigener.top < kasten.bottom;
      abschnitt.classList.toggle("ist-sichtbar", sichtbar);
    }

    zaehlung.textContent = `Handler-Läufe: ${laeufe}, Rechnungen: ${rechnungen}`;
  },
  { passive: true }
);

Naheliegend ist ein Listener auf scroll, der bei jedem Auslösen nachrechnet, wo die Elemente gerade liegen. Das funktioniert. Es ist nur die Art Code, bei der eine Seite ruckelt.

scroll feuert Dutzende Male pro Sekunde. Bei jedem Lauf wird für jedes beobachtete Element getBoundingClientRect aufgerufen, und jeder dieser Aufrufe zwingt den Browser, das Layout auf dem neuesten Stand zu haben. Bei vierzig Elementen sind das bei jeder Bewegung vierzig solcher Rechnungen. Und alle liegen zwischen der Bewegung und dem nächsten Bild auf dem Bildschirm.

Im ersten Beispiel wird beides mitgezählt. Fünf Rastungen am Mausrad, und der Kasten ist unten. Dort steht Handler-Läufe: 5, Rechnungen: 20. Ziehst du denselben Weg langsam am Rollbalken, kommst du schnell auf 30 und 120. Auf dem Bildschirm ist das Ergebnis dasselbe, nur mit sechsmal so viel Arbeit, und die Zahl hängt allein daran, wie jemand scrollt.

Der Observer

Derselbe Effekt mit einem Observer
const fenster = document.getElementById("fenster");
const zaehlung = document.getElementById("zaehlung");

let meldungen = 0;

const beobachter = new IntersectionObserver(
  (eintraege) => {
    for (const eintrag of eintraege) {
      meldungen = meldungen + 1;
      eintrag.target.classList.toggle("ist-sichtbar", eintrag.isIntersecting);
    }
    zaehlung.textContent = `Meldungen insgesamt: ${meldungen}`;
  },
  { root: fenster }
);

for (const abschnitt of document.querySelectorAll(".abschnitt")) {
  beobachter.observe(abschnitt);
}

// Die erste Meldung kommt sofort, ohne dass jemand
// gescrollt hat: der Observer berichtet auch über das,
// was schon sichtbar ist.
console.log("Beobachtung gestartet.");

Ein IntersectionObserver dreht die Sache um. Der Browser erfährt einmal, was dich interessiert, und meldet sich, wenn sich daran etwas ändert.

Der Observer bekommt eine Funktion, die bei Änderungen läuft, und ein Objekt mit Einstellungen. Danach sagst du ihm mit observe(element), worauf er achten soll.

Die Funktion bekommt eine Liste von Einträgen und nicht einen einzelnen. Von jedem Eintrag brauchst du zwei Eigenschaften. target ist das Element, und isIntersecting sagt, ob es gerade sichtbar ist.

Der Gewinn ist mehr als weniger Code. Der Browser weiß ohnehin, wo alles liegt, und muss dafür nichts zusätzlich ausrechnen. Die Funktion läuft nur, wenn ein Element die Grenze überquert.

Gehst du im zweiten Beispiel denselben Weg, steht dort Meldungen insgesamt: 8, egal ob gerastet oder gezogen. Das sind vier Meldungen beim Start und vier für die vier Abschnitte, die unterwegs die Kante überqueren. Die eine Zahl hängt davon ab, wie jemand scrollt, die andere davon, was sich wirklich geändert hat.

Die zwei Einstellungen

threshold und rootMargin
const fenster = document.getElementById("fenster");
const abschnitte = document.querySelectorAll(".abschnitt");

// threshold 0.5: meldet erst, wenn die Hälfte zu sehen ist.
const halb = new IntersectionObserver(
  (eintraege) => {
    for (const eintrag of eintraege) {
      eintrag.target.classList.toggle("halb", eintrag.isIntersecting);
    }
  },
  { root: fenster, threshold: 0.5 }
);

// rootMargin vergrößert den beobachteten Bereich nach
// unten. So lädt man Bilder, bevor sie zu sehen sind.
const vorher = new IntersectionObserver(
  (eintraege) => {
    for (const eintrag of eintraege) {
      eintrag.target.classList.toggle("vorgemerkt", eintrag.isIntersecting);
    }
  },
  { root: fenster, rootMargin: "0px 0px 120px 0px" }
);

for (const abschnitt of abschnitte) {
  halb.observe(abschnitt);
  vorher.observe(abschnitt);
}
  • root ist der Bereich, gegen den gemessen wird. Ohne Angabe ist das das Browserfenster. In den Beispielen dieser Lektion ist es der scrollbare Kasten, damit du den Effekt siehst, ohne die ganze Seite zu scrollen.
  • threshold sagt, wie viel vom Element zu sehen sein muss. 0 heißt „ein Pixel genügt“, 0.5 heißt „die Hälfte“, 1 heißt „vollständig“. Mit einer Liste von Schwellen kommt bei jeder davon eine Meldung.
  • rootMargin vergrößert oder verkleinert den beobachteten Bereich und wird angegeben wie ein CSS-Abstand. 0px 0px 120px 0px beobachtet 120 Pixel weiter nach unten, als tatsächlich zu sehen ist, und so lädt man Bilder, bevor sie ins Bild kommen.

Im dritten Beispiel antwortet halb.thresholds in der Eingabezeile der Console mit [0.5] und vorher.rootMargin mit 0px 0px 120px 0px. Deutlicher wird der Unterschied an den Farben. Beim Laden siehst du vom Vorsprung noch nichts. Den grünen Grund bekommt nur der erste Abschnitt, weil nur der mindestens zur Hälfte zu sehen ist. Der orange Rahmen liegt auf den ersten zwei, die ohnehin zu sehen sind.

Der Vorsprung zeigt sich erst beim Scrollen. Der dritte Abschnitt bekommt seinen Rahmen nach rund 15 gescrollten Pixeln und seinen grünen Grund nach rund 220. Von diesem Abstand kommen 120 Pixel aus rootMargin und der Rest aus der Schwelle. Bei einem Bild sind diese 120 die Zeit, in der es geladen werden kann, bevor jemand hinsieht. Wer schnell scrollt, sieht beides im selben Augenblick.

Die erste Meldung kommt sofort

Gleich nach observe meldet sich der Observer, ohne dass jemand gescrollt hat. Er berichtet über den aktuellen Zustand, und dazu gehört auch das, was schon sichtbar ist. Startest du darin eine Animation, läuft sie beim Laden für alles gleichzeitig los.

Im zweiten Beispiel steht noch vor dem ersten Scrollen Meldungen insgesamt: 4 über dem Kasten, und zwei Abschnitte sind schon grün. Das sind vier Meldungen für vier beobachtete Abschnitte, zwei davon mit isIntersecting: true und zwei mit false, und wer nur auf die Farbe schaut, hält das für zwei Meldungen.

Zählt nur die Änderung, prüfst du isIntersecting und tust bei false einfach nichts. Und was nur einmal passieren soll, hört danach auf zu beobachten.

Aufräumen, wie überall in diesem Kurs

observer.unobserve(element) beendet die Beobachtung eines einzelnen Elements. Das ist der übliche Weg für alles, was einmal passieren soll. Bild geladen, Animation gestartet, fertig.

observer.disconnect() beendet alles auf einmal und gehört in die Abbaumethode einer Komponente, wie das removeEventListener aus Lektion 18.6. Ein Observer, den niemand abmeldet, beobachtet weiter. Er ruft seine Funktion auch für Elemente auf, mit denen längst nichts mehr zu tun ist.

In der Aufgabe markiert ein Observer die Abschnitte, die sichtbar werden, und meldet jeden danach ab.

Zum Mitnehmen

Ein IntersectionObserver meldet sich nur beim Wechsel zwischen sichtbar und unsichtbar, dazu einmal gleich nach observe für jedes Element. Abgemeldet wird mit unobserve oder disconnect.

Jetzt du

Basis Konto, kostenlos

Zu dieser Lektion gehört eine Aufgabe. Du schreibst den Code selbst, und nach jedem Lauf sagt dir eine Prüfliste, was schon stimmt.

Dafür brauchst du das Basis Konto. Es kostet nichts, und ein Passwort gibt es auch nicht.

Was in dieser Lektion steckt

  • Artikel mit 3 Beispielen zum Ausprobieren

    Steht hier, ohne Konto lesbar.

  • Aufgabe im Editor, direkt im Browser geprüft

    Öffnet sich mit dem Basis Konto.