Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript
Web APIs: Intersection Observer i Resize Observer
W tej lekcji8
Dr. Alan Grant stoi przed panoramicznym oknem centrum kontroli Parku Jurajskiego. "Nasze monitory wyświetlają setki elementów jednocześnie - obrazy z kamer, wykresy, mapy sektorów," mówi. "Ale ładowanie wszystkiego naraz zabija wydajność. Potrzebujemy sposobu, aby reagować na to, co użytkownik faktycznie widzi i jak zmienia się układ strony." Odpowiedzią są Intersection Observer i Resize Observer - nowoczesne Web APIs do obserwacji elementów DOM.
Problem: Ręczne śledzenie widoczności
Tradycyjne podejście do sprawdzania, czy element jest widoczny na ekranie, wymaga nasłuchiwania zdarzenia scroll i ręcznego obliczania pozycji:
// Stare podejście - wolne i skomplikowane
window.addEventListener("scroll", () => {
const images = document.querySelectorAll("img[data-src]");
images.forEach(img => {
const rect = img.getBoundingClientRect();
const isVisible = rect.top < window.innerHeight && rect.bottom > 0;
if (isVisible) {
img.src = img.dataset.src; // Załaduj obrazek
}
});
});
// Problem: scroll event odpala się dziesiątki razy na sekundę!
// getBoundingClientRect() może wymusić synchroniczne przeliczenie układu (reflow)Handler uruchamia się dziesiątki razy na sekundę i za każdym razem przelicza pozycje wszystkich obrazków w głównym wątku, tym samym, który obsługuje przewijanie i kliknięcia. Obrazki już załadowane wciąż są sprawdzane, bo nikt nie zdejmuje z nich atrybutu data-src.
Intersection Observer - obserwacja widoczności
IntersectionObserver pozwala asynchronicznie obserwować, kiedy element wchodzi lub wychodzi z widocznego obszaru (viewport) lub innego elementu. To czujnik na granicy wybiegu: nie patrzysz na monitor bez przerwy, tylko dostajesz sygnał, gdy ktoś przekroczy linię:
// Tworzenie obserwatora
const observer = new IntersectionObserver((entries) => {
entries.forEach(entry => {
// entry.isIntersecting - czy element jest widoczny
// entry.intersectionRatio - jaki procent elementu jest widoczny (0-1)
// entry.target - obserwowany element DOM
if (entry.isIntersecting) {
console.log(`Element ${entry.target.id} jest teraz widoczny!`);
console.log(`Widoczność: ${(entry.intersectionRatio * 100).toFixed(0)}%`);
}
});
}, {
// Opcje konfiguracyjne
root: null, // null = viewport przeglądarki
rootMargin: "0px", // margines wokół root (jak CSS margin)
threshold: 0.5 // callback gdy 50% elementu jest widoczne
});
// Rozpoczęcie obserwacji
const dinoCard = document.querySelector("#dino-card");
observer.observe(dinoCard);
// Zatrzymanie obserwacji
// observer.unobserve(dinoCard);
// observer.disconnect(); // Zatrzymuje wszystkie obserwacjeroot to obszar odniesienia, rootMargin poszerza go lub zwęża jak margines w CSS, a threshold mówi, jaka część elementu musi być widoczna, by padł sygnał. Funkcja dostaje tablicę wpisów, bo jeden obserwator pilnuje wielu elementów. Wywoła się też raz tuż po observe(), z bieżącym stanem - dlatego zawsze sprawdzaj isIntersecting.
Lazy loading obrazów
Najpopularniejsze zastosowanie Intersection Observer to lazy loading - ładowanie obrazów dopiero, gdy użytkownik do nich przewinie:
class LazyImageLoader {
constructor(options = {}) {
this.observer = new IntersectionObserver(
(entries) => this.handleIntersection(entries),
{
rootMargin: options.rootMargin || "200px", // Ładuj 200px przed widokiem
threshold: 0
}
);
}
handleIntersection(entries) {
entries.forEach(entry => {
if (entry.isIntersecting) {
const img = entry.target;
// Zamień placeholder na prawdziwy obrazek
img.src = img.dataset.src;
img.classList.add("loaded");
// Przestań obserwować załadowany obrazek
this.observer.unobserve(img);
console.log(`Załadowano obraz: ${img.dataset.src}`);
}
});
}
observe(selector) {
const images = document.querySelectorAll(selector);
images.forEach(img => this.observer.observe(img));
console.log(`Obserwuję ${images.length} obrazów`);
}
destroy() {
this.observer.disconnect();
}
}
// Użycie
const loader = new LazyImageLoader({ rootMargin: "300px" });
loader.observe("img[data-src]");Domyślny rootMargin sprawia, że obraz zaczyna się ładować 200 pikseli przed wejściem na ekran, a w przykładzie użycia nawet 300. Po załadowaniu unobserve() odpina obrazek, żeby obserwator nie pracował na próżno. Dla zwykłych obrazków wystarczy dziś atrybut HTML loading="lazy" - obserwatora użyj, gdy potrzebujesz własnej logiki.
Infinite scroll
Intersection Observer świetnie nadaje się do implementacji nieskończonego przewijania. Zamiast obserwować każdą kartę, pilnujemy jednego niewidocznego znacznika na końcu listy, czyli strażnika:
class InfiniteScroll {
constructor(containerSelector, loadMore) {
this.container = document.querySelector(containerSelector);
this.loadMore = loadMore;
this.isLoading = false;
this.page = 1;
// Tworzymy element "strażnika" na końcu listy
this.sentinel = document.createElement("div");
this.sentinel.className = "scroll-sentinel";
this.container.appendChild(this.sentinel);
// Obserwujemy strażnika
this.observer = new IntersectionObserver(
(entries) => {
if (entries[0].isIntersecting && !this.isLoading) {
this.loadNextPage();
}
},
{ rootMargin: "100px" }
);
this.observer.observe(this.sentinel);
}
async loadNextPage() {
this.isLoading = true;
console.log(`Ładuję stronę ${this.page}...`);
try {
const items = await this.loadMore(this.page);
items.forEach(item => {
const element = document.createElement("div");
element.className = "dino-card";
element.textContent = `${item.name} (${item.species})`;
// Wstawiamy PRZED strażnikiem
this.container.insertBefore(element, this.sentinel);
});
this.page++;
} catch (error) {
console.error("Błąd ładowania:", error);
} finally {
this.isLoading = false;
}
}
}Gdy strażnik zbliży się do ekranu, ładujemy kolejną stronę i wstawiamy karty przed nim, więc on zawsze zostaje na końcu. Flaga isLoading chroni przed podwójnym ładowaniem, a finally zdejmuje ją nawet po błędzie. Dzięki textContent zamiast innerHTML tekst z serwera nigdy nie zostanie potraktowany jak kod HTML.
Walidacja danych i testy
Dane z loadMore() przychodzą z zewnątrz, więc zanim trafią na stronę, przepuść je przez potok walidacji:
- Walidacja schematu - czy odpowiedź to tablica obiektów z polami
nameispecies - Walidacja typów - czy te pola są napisami
- Walidacja reguł biznesowych - czy gatunek istnieje w rejestrze parku
- Sanityzacja - oczyszczenie danych dla bezpieczeństwa przed wyświetleniem
Kod z obserwatorami testuje się warstwami: środowisko jsdom nie ma IntersectionObserver, więc w testach jednostkowych zastępujesz go atrapą, testy integracyjne sprawdzają współpracę klas, a prawdziwe przewijanie weryfikują testy end-to-end w przeglądarce i testy wydajnościowe.
Resize Observer - obserwacja zmian rozmiaru
ResizeObserver powiadamia, gdy element zmieni swoje wymiary. Jest nieoceniony dla responsywnych komponentów, a schemat użycia jest ten sam co wyżej:
// Tworzenie Resize Observer
const resizeObserver = new ResizeObserver((entries) => {
entries.forEach(entry => {
const { width, height } = entry.contentRect;
console.log(`Element ${entry.target.id} zmienił rozmiar: ${width}x${height}`);
});
});
// Obserwacja elementu
const mapContainer = document.querySelector("#park-map");
resizeObserver.observe(mapContainer);contentRect opisuje obszar treści, bez ramki i paddingu. To starsze pole zachowane dla zgodności - nowsze contentBoxSize i borderBoxSize są dokładniejsze. W przeciwieństwie do zdarzenia resize okna obserwator reaguje na zmianę rozmiaru konkretnego elementu, bez względu na przyczynę.
Responsywny komponent z Resize Observer
Obserwator rozmiaru pozwala siatce kart dopasować liczbę kolumn do własnej szerokości, a nie do szerokości całego okna:
class ResponsiveDinoGrid {
constructor(containerSelector) {
this.container = document.querySelector(containerSelector);
this.currentLayout = null;
this.observer = new ResizeObserver((entries) => {
const entry = entries[0];
const width = entry.contentRect.width;
this.updateLayout(width);
});
this.observer.observe(this.container);
}
updateLayout(width) {
let newLayout;
if (width < 400) {
newLayout = "single-column";
this.container.style.gridTemplateColumns = "1fr";
} else if (width < 800) {
newLayout = "two-columns";
this.container.style.gridTemplateColumns = "1fr 1fr";
} else {
newLayout = "multi-column";
this.container.style.gridTemplateColumns = "repeat(auto-fill, minmax(250px, 1fr))";
}
if (newLayout !== this.currentLayout) {
this.currentLayout = newLayout;
console.log(`Layout zmieniony na: ${newLayout} (szerokość: ${width}px)`);
}
}
destroy() {
this.observer.disconnect();
}
}Siatka przełącza układ przy 400 i 800 pikselach, a komunikat wypisuje tylko przy faktycznej zmianie układu. Gdy chodzi wyłącznie o wygląd, rozważ CSS container queries, a obserwator zostaw na logikę, której CSS nie wyrazi.
Łączenie obu Observerów
Oba obserwatory świetnie się uzupełniają. Panel monitoringu włącza tylko widoczne kamery i dobiera jakość obrazu do rozmiaru kafelka:
// System panelu monitoringu Parku Jurajskiego
class MonitoringPanel {
constructor(panelSelector) {
this.panel = document.querySelector(panelSelector);
this.cameras = [];
// Intersection Observer - włączaj/wyłączaj kamery w zależności od widoczności
this.visibilityObserver = new IntersectionObserver(
(entries) => this.handleVisibility(entries),
{ threshold: 0.1 }
);
// Resize Observer - dostosuj jakość obrazu do rozmiaru panelu
this.resizeObserver = new ResizeObserver(
(entries) => this.handleResize(entries)
);
}
addCamera(cameraElement) {
this.cameras.push(cameraElement);
this.visibilityObserver.observe(cameraElement);
this.resizeObserver.observe(cameraElement);
}
handleVisibility(entries) {
entries.forEach(entry => {
const cameraId = entry.target.dataset.cameraId;
if (entry.isIntersecting) {
console.log(`Kamera ${cameraId}: WŁĄCZONA (widoczna)`);
entry.target.classList.add("active");
} else {
console.log(`Kamera ${cameraId}: WSTRZYMANA (poza widokiem)`);
entry.target.classList.remove("active");
}
});
}
handleResize(entries) {
entries.forEach(entry => {
const { width } = entry.contentRect;
const cameraId = entry.target.dataset.cameraId;
let quality;
if (width < 200) quality = "low";
else if (width < 500) quality = "medium";
else quality = "high";
entry.target.dataset.quality = quality;
console.log(`Kamera ${cameraId}: jakość = ${quality} (szer: ${width}px)`);
});
}
destroy() {
this.visibilityObserver.disconnect();
this.resizeObserver.disconnect();
}
}Każda kamera jest pilnowana przez oba obserwatory naraz, a destroy() odłącza je metodą disconnect(). Bez tego obserwatory działałyby dalej, choć panel dawno zniknął.
Podsumowanie
Dr. Grant podsumowuje: "Obserwatory to jak nasz system czujników w parku - nie musimy ciągle sprawdzać każdej kamery ręcznie:"
- IntersectionObserver - reaguje, gdy element wchodzi/wychodzi z widocznego obszaru
- Lazy loading - ładuj obrazy/treści dopiero gdy użytkownik do nich przewinie
- Infinite scroll - automatycznie doładowuj dane przy przewijaniu
- ResizeObserver - reaguje na zmianę rozmiaru elementów DOM
- Responsywne komponenty - dostosowuj layout bez media queries
Oba API są asynchroniczne i znacznie wydajniejsze niż ręczne nasłuchiwanie scroll czy resize. Przeglądarka sama wylicza przecięcia i rozmiary, a Twój callback woła dopiero wtedy, gdy coś się zmieni. Sam callback działa jednak w głównym wątku, więc powinien być krótki. Z obserwatorami spotkasz się znowu w lokacji o lazy loadingu obrazów, tras i komponentów, a w laboratorium poniżej wypróbujesz je od razu.
Pamiętaj: obserwatory to czujniki na granicy wybiegu - odzywają się tylko wtedy, gdy coś naprawdę przekroczy linię.
Kod do tej lekcji: index.js
// Web APIs: Intersection Observer i Resize Observer
// Park Jurajski - System monitoringu
console.log("=== INTERSECTION OBSERVER ===");
// Symulacja IntersectionObserver (w przegladarce dziala z DOM)
// Pokaz koncepcji - jak wyglada API
// Tworzenie obserwatora
// const observer = new IntersectionObserver((entries) => {
// entries.forEach(entry => {
// if (entry.isIntersecting) {
// console.log("Element widoczny:", entry.target.id);
// }
// });
// }, {
// root: null, // viewport przegladarki
// rootMargin: "0px", // margines
// threshold: 0.5 // 50% widocznosci
// });
// === LAZY LOADING ===
console.log("\n=== LAZY LOADING (koncepcja) ===");
class LazyImageLoader {
constructor(rootMargin = "200px") {
this.loadedImages = [];
this.rootMargin = rootMargin;
// W przegladarce: this.observer = new IntersectionObserver(...)
}
// Symulacja ladowania obrazka
loadImage(imageData) {
console.log(`Ladowanie obrazu: ${imageData.src}`);
this.loadedImages.push(imageData.src);
return { ...imageData, loaded: true };
}
getStats() {
return {
loaded: this.loadedImages.length,
images: this.loadedImages
};
}
}
const loader = new LazyImageLoader("300px");
loader.loadImage({ src: "/cameras/sector-a.jpg", alt: "Sektor A" });
loader.loadImage({ src: "/cameras/sector-b.jpg", alt: "Sektor B" });
console.log("Statystyki:", loader.getStats());
// === INFINITE SCROLL ===
console.log("\n=== INFINITE SCROLL (symulacja) ===");
class InfiniteScroll {
constructor(loadMore) {
this.loadMore = loadMore;
this.page = 0;
this.items = [];
this.isLoading = false;
}
async loadNextPage() {
if (this.isLoading) return;
this.isLoading = true;
this.page++;
console.log(`Laduje strone ${this.page}...`);
const newItems = await this.loadMore(this.page);
this.items.push(...newItems);
this.isLoading = false;
return newItems;
}
getAll() {
return [...this.items];
}
}
// Symulacja API
const fetchDinosaurs = (page) => {
return Promise.resolve([
{ name: `Dino-${page}A`, species: "T-Rex" },
{ name: `Dino-${page}B`, species: "Velociraptor" },
{ name: `Dino-${page}C`, species: "Triceratops" },
]);
};
const scroll = new InfiniteScroll(fetchDinosaurs);
// Ladowanie stron
async function demo() {
await scroll.loadNextPage();
await scroll.loadNextPage();
await scroll.loadNextPage();
console.log("Wszystkie zaladowane:", scroll.getAll().length, "dinozaurow");
console.log("Elementy:", scroll.getAll().map(d => d.name));
}
demo();
// === RESIZE OBSERVER ===
console.log("\n=== RESIZE OBSERVER (koncepcja) ===");
class ResponsiveDinoGrid {
constructor() {
this.currentLayout = null;
}
updateLayout(width) {
let newLayout;
if (width < 400) newLayout = "single-column";
else if (width < 800) newLayout = "two-columns";
else newLayout = "multi-column";
if (newLayout !== this.currentLayout) {
this.currentLayout = newLayout;
console.log(`Layout: ${newLayout} (szerokosc: ${width}px)`);
}
return newLayout;
}
}
const grid = new ResponsiveDinoGrid();
grid.updateLayout(300); // single-column
grid.updateLayout(600); // two-columns
grid.updateLayout(1200); // multi-column
// TODO: Stworz klase MonitoringPanel
// ktora laczy IntersectionObserver (wlaczanie kamer)
// z ResizeObserver (dostosowanie jakosci)
console.log("\n=== Cwiczenie ===");
console.log("Stworz MonitoringPanel - patrz TODO w kodzie");Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Do czego służy IntersectionObserver w JavaScript?
2. Dlaczego IntersectionObserver jest lepszy od nasłuchiwania zdarzenia scroll do implementacji lazy loading?
Zadania praktyczne w grze
- Edytor kodu
Zaimplementuj lazy loading obrazów z IntersectionObserver i responsywną siatkę z ResizeObserver.
- Układanie w poziomie
Ułóż elementy tworzenia i użycia ResizeObserver:
- Układanie w pionie
Uporządkuj etapy testowania aplikacji od jednostkowych do systemowych:
- Układanie w pionie
Uporządkuj pipeline walidacji danych: