Kurs JavaScript i TypeScript · Moduł 8: Zdarzenia i DOM

Zaawansowane techniki obsługi wydarzeń

4 min czytania ·

Specjalistyczne techniki dla zaawansowanych przypadków użycia.

Goście parku coraz częściej przeglądają galerię dinozaurów na telefonach i tabletach. Tam nie ma myszy, a samo wydarzenie click nie powie Ci, w którą stronę ktoś przesunął palcem. Przeglądarka zgłasza za to trzy wydarzenia dotykowe po kolei: touchstart, gdy palec dotyka ekranu, touchmove, gdy przesuwa się po nim, i touchend, gdy go opuszcza. Z tych trzech sygnałów zbudujemy rozpoznawanie gestów, tak jak tropiciel odczytuje kierunek marszu stada ze śladów w błocie.

Obsługa gestów touch

Cała logika zamieszka w klasie TouchGestureHandler. Konstruktor zapamiętuje element i przygotowuje miejsce na współrzędne początku oraz bieżącej pozycji palca.

// Obsługa gestów dotykowych dla urządzeń mobilnych
class TouchGestureHandler {
  constructor(element) {
    this.element = element;
    this.startX = 0;
    this.startY = 0;
    this.currentX = 0;
    this.currentY = 0;
    this.isTracking = false;

    this.bindEvents();
  }

  bindEvents() {
    this.element.addEventListener('touchstart', (e) => this.handleTouchStart(e));
    this.element.addEventListener('touchmove', (e) => this.handleTouchMove(e));
    this.element.addEventListener('touchend', (e) => this.handleTouchEnd(e));
  }

Metoda bindEvents() podpina trzy listenery, a funkcje strzałkowe zachowują this jako instancję klasy. Flaga isTracking mówi, czy trwa jakiś gest. Pierwszy sygnał to dotknięcie ekranu.

  handleTouchStart(e) {
    this.isTracking = true;
    this.startX = e.touches[0].clientX;
    this.startY = e.touches[0].clientY;
    this.currentX = this.startX; // stuknięcie bez ruchu = zerowe przesunięcie
    this.currentY = this.startY;
  }

Właściwość e.touches to lista wszystkich palców, które w tej chwili dotykają ekranu, a touches[0] to pierwszy z nich. Jego clientX i clientY działają tak samo jak przy myszy. Dwie ostatnie linie to poprawka: zerują przesunięcie na starcie, więc samo stuknięcie bez ruchu nie porówna startu z pozycją z poprzedniego gestu i nie wywoła fantomowego przesunięcia. Teraz ruch palca.

  handleTouchMove(e) {
    if (!this.isTracking) return;

    e.preventDefault();
    this.currentX = e.touches[0].clientX;
    this.currentY = e.touches[0].clientY;

    const deltaX = this.currentX - this.startX;
    const deltaY = this.currentY - this.startY;

    // Emituj custom event z danymi gestu
    this.element.dispatchEvent(new CustomEvent('gesture', {
      detail: { deltaX, deltaY, isActive: true }
    }));
  }

Wywołanie preventDefault() blokuje przewijanie strony podczas gestu, ale działa tylko w listenerze, który nie jest pasywny. Tu nie ma problemu, bo nasłuchujemy na zwykłym elemencie. Na window, document, document.documentElement i body przeglądarki traktują touchstart i touchmove domyślnie jako pasywne i takie wywołanie zignorują. W trakcie ruchu klasa emituje własne wydarzenie gesture z przesunięciem w detail, więc karta może na bieżąco podążać za palcem. Na końcu palec opuszcza ekran.

  handleTouchEnd(e) {
    if (!this.isTracking) return;

    this.isTracking = false;
    const deltaX = this.currentX - this.startX;
    const deltaY = this.currentY - this.startY;

    // Określ typ gestu
    if (Math.abs(deltaX) > Math.abs(deltaY)) {
      // Poziomy gest
      if (deltaX > 50) {
        this.element.dispatchEvent(new CustomEvent('swipeRight'));
      } else if (deltaX < -50) {
        this.element.dispatchEvent(new CustomEvent('swipeLeft'));
      }
    } else {
      // Pionowy gest
      if (deltaY > 50) {
        this.element.dispatchEvent(new CustomEvent('swipeDown'));
      } else if (deltaY < -50) {
        this.element.dispatchEvent(new CustomEvent('swipeUp'));
      }
    }

    this.element.dispatchEvent(new CustomEvent('gestureEnd', {
      detail: { deltaX, deltaY }
    }));
  }
}

W touchend lista e.touches nie zawiera już podniesionego palca, trafia on do e.changedTouches, dlatego korzystamy z zapamiętanych currentX i currentY. Porównanie Math.abs() ustala dominującą oś ruchu. Próg 50 pikseli odróżnia świadomy gest od drżenia palca. Oś Y na ekranie rośnie w dół, więc dodatnie deltaY oznacza przesunięcie w dół. Cała sekwencja zawsze wygląda tak samo: touchstart, seria touchmove, touchend, a na końcu analiza deltaX i deltaY oraz emisja własnego wydarzenia. Istnieje też czwarte wydarzenie, touchcancel, które przychodzi, gdy system przerwie dotyk, na przykład przy zbyt wielu palcach naraz. W jego obsłudze wystarczy wyzerować flagę isTracking.

Użycie w galerii dinozaurów

Klasa niczego nie wie o galerii, tylko nadaje wydarzenia. Galeria słucha tych, które ją interesują.

const dinoGallery = document.getElementById('dino-gallery');
new TouchGestureHandler(dinoGallery);

dinoGallery.addEventListener('swipeLeft', () => showNextDinosaur());
dinoGallery.addEventListener('swipeRight', () => showPreviousDinosaur());

Przesunięcie w lewo pokazuje następnego dinozaura, a w prawo poprzedniego. Pamiętaj, że CustomEvent domyślnie nie bąbelkuje, więc listenery muszą wisieć na tym samym elemencie, który przekazaliśmy do handlera. Dokładnie ten podział ról poznałeś przy własnych wydarzeniach: jeden moduł wykrywa, drugi reaguje.

Moja rada: jeśli budujesz od zera komponent, który ma działać zarówno myszą, jak i palcem, sprawdź Pointer Events (pointerdown, pointermove, pointerup). Obsługują mysz, pióro i dotyk jednym zestawem wydarzeń. Touch Events wciąż przydają się tam, gdzie potrzebujesz listy wszystkich palców, na przykład przy geście szczypania. W piaskownicy poniżej przetestujesz gesty na obszarze dotykowym, a na komputerze także myszą. W następnej lekcji zajmiemy się wydajnością, w tym pasywnymi listenerami.

Pamiętaj: gest to ślad w błocie, który odczytujesz dopiero wtedy, gdy dinozaur podniesie łapę, czyli w touchend.

Kod do tej lekcji: index.html
<!DOCTYPE html>
<html lang="pl">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Touch Gestures</title>
    <style>
        body { font-family: Arial, sans-serif; background: linear-gradient(135deg, #2c3e50, #34495e); color: white; padding: 20px; touch-action: none; }
        .touch-area { width: 100%; height: 300px; background: rgba(52, 152, 219, 0.2); border: 2px dashed #3498db; border-radius: 10px; display: flex; align-items: center; justify-content: center; font-size: 24px; margin: 20px 0; }
        .info { background: rgba(0,0,0,0.6); padding: 15px; border-radius: 8px; margin: 10px 0; }
    </style>
</head>
<body>
    <h1>Touch Gestures - Sterowanie Dotykowe</h1>
    <div class="info">
        <p>Przeciągnij palcem: ←→ (poziomo) lub ↑↓ (pionowo)</p>
        <p id="gesture-info">Czekam na gest...</p>
    </div>
    <div class="touch-area" id="touch-area">Dotknij i przeciągnij</div>
    <div class="info">
        <strong>Wykryte gesty:</strong>
        <ul id="gesture-log"></ul>
    </div>

    <script>
        console.log('Touch Gesture Handler initialized');

        const touchArea = document.getElementById('touch-area');
        const gestureInfo = document.getElementById('gesture-info');
        const gestureLog = document.getElementById('gesture-log');

        let startX = 0, startY = 0;
        let currentX = 0, currentY = 0;
        let isTracking = false;

        function logGesture(message) {
            const li = document.createElement('li');
            li.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
            gestureLog.insertBefore(li, gestureLog.firstChild);
            if (gestureLog.children.length > 5) {
                gestureLog.removeChild(gestureLog.lastChild);
            }
        }

        touchArea.addEventListener('touchstart', (e) => {
            isTracking = true;
            startX = e.touches[0].clientX;
            startY = e.touches[0].clientY;
            currentX = startX;
            currentY = startY;
            gestureInfo.textContent = 'Rozpoczęto gest...';
            touchArea.style.background = 'rgba(46, 204, 113, 0.2)';
            console.log('Touch start:', startX, startY);
        });

        touchArea.addEventListener('touchmove', (e) => {
            if (!isTracking) return;
            e.preventDefault();

            currentX = e.touches[0].clientX;
            currentY = e.touches[0].clientY;

            const deltaX = currentX - startX;
            const deltaY = currentY - startY;

            gestureInfo.textContent = `Δ X: ${Math.round(deltaX)}px, Y: ${Math.round(deltaY)}px`;
        });

        touchArea.addEventListener('touchend', (e) => {
            if (!isTracking) return;
            isTracking = false;

            const deltaX = currentX - startX;
            const deltaY = currentY - startY;

            touchArea.style.background = 'rgba(52, 152, 219, 0.2)';

            let gesture = 'Nierozpoznany';

            if (Math.abs(deltaX) > Math.abs(deltaY)) {
                if (deltaX > 50) {
                    gesture = '→ Swipe Right';
                    touchArea.textContent = '→ W prawo';
                } else if (deltaX < -50) {
                    gesture = '← Swipe Left';
                    touchArea.textContent = '← W lewo';
                }
            } else {
                if (deltaY > 50) {
                    gesture = '↓ Swipe Down';
                    touchArea.textContent = '↓ W dół';
                } else if (deltaY < -50) {
                    gesture = '↑ Swipe Up';
                    touchArea.textContent = '↑ W górę';
                }
            }

            logGesture(gesture);
            console.log(`Gesture detected: ${gesture}`);

            setTimeout(() => {
                touchArea.textContent = 'Dotknij i przeciągnij';
                gestureInfo.textContent = 'Czekam na kolejny gest...';
            }, 1500);
        });

        // Fallback dla myszy (do testowania na desktop)
        let mouseDown = false;
        touchArea.addEventListener('mousedown', (e) => {
            mouseDown = true;
            startX = e.clientX;
            startY = e.clientY;
            currentX = startX;
            currentY = startY;
        });

        touchArea.addEventListener('mousemove', (e) => {
            if (!mouseDown) return;
            currentX = e.clientX;
            currentY = e.clientY;
            const deltaX = currentX - startX;
            const deltaY = currentY - startY;
            gestureInfo.textContent = `Mouse Δ X: ${Math.round(deltaX)}px, Y: ${Math.round(deltaY)}px`;
        });

        touchArea.addEventListener('mouseup', () => {
            if (mouseDown) {
                mouseDown = false;
                const deltaX = currentX - startX;
                const deltaY = currentY - startY;

                if (Math.abs(deltaX) > 50 || Math.abs(deltaY) > 50) {
                    logGesture('Mouse gesture detected');
                }
            }
        });

        console.log('Touch gestures ready - swipe to test!');
    </script>
</body>
</html>

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. Które zdarzenie jest wywoływane, gdy użytkownik przesuwa palcem po ekranie dotykowym?

Zadania praktyczne w grze

  • Edytor kodu

    W pliku index.js jest klasa TouchGestureHandler z lekcji o gestach. Uzupełnij luki: ___BLANK1___ to zdarzenie dotyku wysyłane, gdy palec przesuwa się po ekranie, ___BLANK2___ to nazwa kierunku, gdy palec przesunął się w górę o więcej niż 50 px, a ___BLANK3___ to pole opcji CustomEvent, w którym zdarzenie swipe niesie dane { direction, deltaX, deltaY }. Przesunięcie o więcej niż 50 px ma wysłać jedno zdarzenie swipe z kierunkiem left, right, up albo down, a stuknięcie i drobny ruch żadnego.

  • Układanie w pionie

    Ułóż zdarzenia dotykowe w kolejności, w jakiej występują podczas przesunięcia palcem po ekranie:

  1. PytanieTouch events w JavaScript
  2. Zadanie z kodemĆwiczenie: Obsługa gestów dotykowych
  3. Ułóż w kolejnościKolejność zdarzeń dotykowych

Przydatne artykuły