Abschnitt 19 · Lektion 3
Sichtbarkeit beobachten
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
<p id="zaehlung">Scroll im Kasten.</p>
<div id="fenster">
<div class="abschnitt">Eins</div>
<div class="abschnitt">Zwei</div>
<div class="abschnitt">Drei</div>
<div class="abschnitt">Vier</div>
</div> #fenster {
height: 200px;
overflow: auto;
border: 1px solid #78716c;
}
.abschnitt {
height: 150px;
padding: 8px;
border-bottom: 1px solid #d6d3d1;
font-family: system-ui, sans-serif;
}
.abschnitt.ist-sichtbar {
background: #bbf7d0;
} 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
<p id="zaehlung">Scroll im Kasten.</p>
<div id="fenster">
<div class="abschnitt">Eins</div>
<div class="abschnitt">Zwei</div>
<div class="abschnitt">Drei</div>
<div class="abschnitt">Vier</div>
</div> #fenster {
height: 200px;
overflow: auto;
border: 1px solid #78716c;
}
.abschnitt {
height: 150px;
padding: 8px;
border-bottom: 1px solid #d6d3d1;
font-family: system-ui, sans-serif;
}
.abschnitt.ist-sichtbar {
background: #bbf7d0;
} 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
<p id="zaehlung">Scroll langsam und sieh auf die Farben.</p>
<div id="fenster">
<div class="abschnitt">Eins</div>
<div class="abschnitt">Zwei</div>
<div class="abschnitt">Drei</div>
<div class="abschnitt">Vier</div>
</div> #fenster {
height: 200px;
overflow: auto;
border: 1px solid #78716c;
}
.abschnitt {
height: 150px;
padding: 8px;
border-bottom: 1px solid #d6d3d1;
font-family: system-ui, sans-serif;
}
.abschnitt.halb {
background: #bbf7d0;
}
.abschnitt.vorgemerkt {
outline: 3px solid #f59e0b;
outline-offset: -3px;
} 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);
} rootist 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.thresholdsagt, wie viel vom Element zu sehen sein muss.0heißt „ein Pixel genügt“,0.5heißt „die Hälfte“,1heißt „vollständig“. Mit einer Liste von Schwellen kommt bei jeder davon eine Meldung.rootMarginvergrößert oder verkleinert den beobachteten Bereich und wird angegeben wie ein CSS-Abstand.0px 0px 120px 0pxbeobachtet 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, kostenlosZu 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.