Kurs JavaScript i TypeScript · Moduł 5: Zaawansowany JavaScript

Profilery i narzędzia wydajnościowe

5 min czytania ·
W tej lekcji7

W Parku Jurajskim, wydajność systemów informatycznych jest kluczowa dla bezpieczeństwa. Wyobraź sobie, że system monitorowania drapieżników zaczyna działać wolno - opóźnienie nawet o kilka sekund może być różnicą między bezpieczną obserwacją a niebezpiecznym incydentem! Podobnie jak naukowcy parku używają zaawansowanych narzędzi do monitorowania zdrowia dinozaurów, programiści mają do dyspozycji profilery i narzędzia wydajnościowe, które pomagają identyfikować "wąskie gardła" w aplikacjach.

Czym są profilery?

Profilery to narzędzia, które zbierają dane o działaniu aplikacji w czasie rzeczywistym, analizując zużycie pamięci, czas wykonania funkcji i inne wskaźniki wydajności. To jak kamery termowizyjne używane przez pracowników parku do monitorowania aktywności dinozaurów - pozwalają zobaczyć co normalnie pozostaje niewidoczne.

Performance API

JavaScript oferuje wbudowane Performance API, które pozwala mierzyć czas wykonania kodu:

// Monitoring czasu ładowania danych o dinozaurach
console.time('fetchDinosaurData');

fetchDinosaurDataFromAPI()
  .then(data => {
    console.timeEnd('fetchDinosaurData');  // Wyświetli: fetchDinosaurData: 1250.33ms
    updateDinosaurMonitoringSystem(data);
  });

Metody console.time() i console.timeEnd() są prostym sposobem na mierzenie czasu wykonania operacji. Możemy też użyć bardziej precyzyjnego API:

// Bardziej zaawansowane mierzenie czasu
const startTime = performance.now();

processDinosaurMovementData(velociraptorSensorData);

const endTime = performance.now();
console.log(`Przetwarzanie danych ruchu zajęło ${endTime - startTime} milisekund`);

Narzędzia Performance w przeglądarkach

Wszystkie nowoczesne przeglądarki oferują zaawansowane narzędzia do analizy wydajności:

1. Panel Performance w Chrome DevTools

Zakładka Performance w Chrome DevTools pozwala nagrywać i analizować działanie aplikacji, identyfikując:

  • Długotrwałe operacje blokujące główny wątek
  • Nadmierny rendering
  • Zużycie pamięci
  • Zdarzenia, które powodują przewijanie lub animacje niezgodne z założonym FPS

Przykład użycia:

  1. Otwórz narzędzia deweloperskie (<kbd>F12</kbd> lub <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>I</kbd>)
  2. Przejdź do zakładki "Performance"
  3. Kliknij przycisk nagrywania (record)
  4. Wykonaj operacje w aplikacji, które chcesz przeanalizować
  5. Zatrzymaj nagrywanie
  6. Przeanalizuj wynikowy wykres, który pokazuje aktywność JavaScript, renderowanie, pamięć, itp.

2. Profiler JavaScript

Chrome DevTools oferuje również specjalny profiler JavaScript, który pozwala na precyzyjne śledzenie czasu wykonania poszczególnych funkcji:

  1. Przejdź do zakładki "Performance" lub "Profiler"
  2. Wybierz "JavaScript Profiler" lub "JS Profiler"
  3. Naciśnij "Start"
  4. Wykonaj operacje do profilowania
  5. Naciśnij "Stop"

Wyniki pokażą "flamegraph" (wykres płomieni), który przedstawia hierarchię wywołań funkcji i czas spędzony w każdej z nich.

Memory Profiling - Analiza wykorzystania pamięci

Jednym z najczęstszych problemów wydajnościowych jest wyciek pamięci (memory leak). W Parku Jurajskim, wyciek pamięci w systemie monitorowania mógłby spowodować jego spowolnienie, a nawet awarię w krytycznym momencie!

Chrome DevTools oferuje narzędzia do analizy wykorzystania pamięci:

  1. Przejdź do zakładki "Memory"
  2. Wybierz typ zrzutu pamięci (Heap snapshot, Allocation instrumentation, itp.)
  3. Wykonaj zrzut pamięci
  4. Analizuj wyniki, szukając obiektów, które zajmują dużo pamięci lub których liczba nadmiernie rośnie
// Przykład potencjalnego wycieku pamięci w systemie Parku Jurajskiego
const dinoMonitoringSystem = {
  sensorReadings: [],
  startMonitoring() {
    // Ten setInterval nigdy nie jest czyszczony, co może prowadzić do wycieku pamięci
    setInterval(() => {
      this.sensorReadings.push({
        timestamp: Date.now(),
        readings: generateRandomSensorData()
      });
      // Tablica sensorReadings będzie rosła w nieskończoność!
    }, 1000);
  }
};

// Lepsze podejście: zapamiętaj referencję do interwału i wyczyść ją gdy już nie jest potrzebna
const betterDinoMonitoringSystem = {
  sensorReadings: [],
  intervalId: null,
  startMonitoring() {
    this.intervalId = setInterval(() => {
      // Utrzymuj tylko ostatnie 100 odczytów
      if (this.sensorReadings.length >= 100) {
        this.sensorReadings.shift(); // Usuń najstarszy odczyt
      }
      this.sensorReadings.push({
        timestamp: Date.now(),
        readings: generateRandomSensorData()
      });
    }, 1000);
  },
  stopMonitoring() {
    clearInterval(this.intervalId);
    this.intervalId = null;
  }
};

Lighthouse - kompleksowa analiza wydajności

Lighthouse to narzędzie wbudowane w Chrome DevTools, które analizuje stronę internetową pod kątem wydajności, dostępności, SEO i innych aspektów. Jest szczególnie przydatne do optymalizacji aplikacji webowych.

Wyobraź sobie, że tworzysz stronę internetową dla Parku Jurajskiego, która musi szybko ładować się dla potencjalnych gości. Lighthouse pomoże zidentyfikować problemy, które mogą spowalniać stronę.

Praktyczne wskazówki dotyczące optymalizacji wydajności

Na podstawie doświadczeń z zarządzania systemami Parku Jurajskiego, oto kilka praktycznych wskazówek:

  1. Unikaj nadmiernych obliczeń w głównym wątku

    // Zamiast:
    function analyzeDinosaurBehavior(dinoData) {
      // Intensywne obliczenia blokujące interface użytkownika
    }
    
    // Lepiej:
    function analyzeDinosaurBehavior(dinoData) {
      // Przygotuj dane wstępnie
      requestAnimationFrame(() => {
        // Wykonaj obliczenia między klatkami animacji
        // lub użyj Web Worker dla naprawdę intensywnych obliczeń
      });
    }
  2. Korzystaj z technik buforowania (memoization)

    // Buforowanie wyników kosztownych obliczeń
    const memoizedCalculations = new Map();
    
    function calculateDinosaurGrowthProjection(species, age, diet) {
      const key = `${species}-${age}-${diet}`;
    
      if (memoizedCalculations.has(key)) {
        return memoizedCalculations.get(key); // Zwróć zapisany wynik
      }
    
      // Wykonaj skomplikowane obliczenia tylko jeśli nie ma w buforze
      const result = performExpensiveCalculation(species, age, diet);
      memoizedCalculations.set(key, result);
    
      return result;
    }
  3. Optymalizuj operacje DOM

    // Zamiast:
    function updateDinosaurStatuses(dinosaurs) {
      dinosaurs.forEach(dino => {
        const element = document.getElementById(`dino-${dino.id}`);
        element.className = dino.status; // Każda zmiana powoduje reflow
        element.textContent = dino.name;
        element.style.backgroundColor = getStatusColor(dino.status);
      });
    }
    
    // Lepiej:
    function updateDinosaurStatuses(dinosaurs) {
      // Minimalizuj operacje na DOM grupując je
      const fragment = document.createDocumentFragment();
    
      dinosaurs.forEach(dino => {
        const element = document.createElement('div');
        element.id = `dino-${dino.id}`;
        element.className = dino.status;
        element.textContent = dino.name;
        element.style.backgroundColor = getStatusColor(dino.status);
        fragment.appendChild(element);
      });
    
      // Jedna operacja na DOM zamiast wielu
      const container = document.getElementById('dinosaur-status-container');
      container.innerHTML = ''; // Wyczyść kontener
      container.appendChild(fragment);
    }

Wnioski

Regularny profiling i analiza wydajności są tak samo ważne w programowaniu, jak regularne kontrole bezpieczeństwa w Parku Jurajskim. Dzięki tym narzędziom możemy wykrywać i eliminować problemy wydajnościowe, zanim doprowadzą do "incydentów" w naszej aplikacji.

W następnym ćwiczeniu przyjrzymy się typom błędów występujących w JavaScript i strategiom radzenia sobie z nimi - nawet w najbardziej nieprzewidywalnych sytuacjach, jak niespodziewana ucieczka welociraptora z zagrody!

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 zakładka Performance w DevTools przeglądarki?

  2. 2. Co może powodować wyciek pamięci (memory leak) w JavaScript?

Zadania praktyczne w grze

  • Edytor kodu

    Zmierz czas operacji filtrowania i stwórz funkcję memoize() cachującą wyniki.

  • Układanie w pionie

    Uporządkuj etapy profilowania wydajności aplikacji:

  1. PytanieZakładka Performance w DevTools
  2. PytanieWyciek pamięci w JavaScript
  3. Zadanie z kodemPraktyka: Mierzenie wydajności kodu
  4. Ułóż w kolejnościEtapy profilowania wydajności

Przydatne artykuły