Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Web APIs: Intersection Observer i Resize Observer

8 min czytania ·
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 obserwacje

root 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:

  1. Walidacja schematu - czy odpowiedź to tablica obiektów z polami name i species
  2. Walidacja typów - czy te pola są napisami
  3. Walidacja reguł biznesowych - czy gatunek istnieje w rejestrze parku
  4. 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:"

  1. IntersectionObserver - reaguje, gdy element wchodzi/wychodzi z widocznego obszaru
  2. Lazy loading - ładuj obrazy/treści dopiero gdy użytkownik do nich przewinie
  3. Infinite scroll - automatycznie doładowuj dane przy przewijaniu
  4. ResizeObserver - reaguje na zmianę rozmiaru elementów DOM
  5. 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. 1. Do czego służy IntersectionObserver w JavaScript?

  2. 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:

  1. PytanieIntersectionObserver - zastosowanie
  2. PytanieLazy loading z IntersectionObserver
  3. Zadanie z kodemPraktyka: Intersection Observer i Resize Observer
  4. Ułóż w kolejnościSkładnia tworzenia ResizeObserver
  5. Ułóż w kolejnościEtapy testowania aplikacji
  6. Ułóż w kolejnościPipeline walidacji danych

Przydatne artykuły