Kurs JavaScript i React · Moduł 8: Zaawansowane wzorce React

Profilowanie wydajności

11 min czytania ·
W tej lekcji7

Nasza kosmiczna podróż przez React zbliża się do końca, ale zanim wyruszymy na dalsze eksploracje, musimy upewnić się, że nasz statek kosmiczny działa na maksymalnych obrotach. W tym module skupimy się na profilowaniu wydajności aplikacji React - czyli identyfikacji i analizie "wąskich gardeł" w naszym kodzie.

Czym jest profilowanie wydajności?

Profilowanie wydajności to proces identyfikacji miejsc w aplikacji, które zużywają najwięcej zasobów (czas procesora, pamięć) i mogą prowadzić do wolnego działania interfejsu użytkownika. Jest to jak diagnozowanie silników statku kosmicznego, aby sprawdzić, które części nie działają wydajnie i mogą zostać zoptymalizowane.

W kontekście aplikacji React, profilowanie pozwala na:

  • Identyfikację komponentów, które renderują się zbyt często
  • Zlokalizowanie długo trwających operacji
  • Zrozumienie wzorców renderowania
  • Wykrycie niepotrzebnych aktualizacji stanu
  • Wskazanie miejsc wymagających optymalizacji

Narzędzia do profilowania React

1. React DevTools Profiler

React DevTools to rozszerzenie do przeglądarki, które pozwala na analizę wydajności aplikacji React. Zawiera ono zakładkę "Profiler", która jest najprostszym i najpotężniejszym narzędziem do profilowania aplikacji React.

Jak używać React DevTools Profiler:

  1. Instalacja React DevTools

  2. Uruchomienie profilowania:

    • Otwórz narzędzia deweloperskie w przeglądarce
    • Przejdź do zakładki "Profiler" w React DevTools
    • Kliknij przycisk nagrywania (czerwony kółko)
    • Wykonaj akcje w aplikacji, które chcesz profilować
    • Zatrzymaj nagrywanie
  3. Analiza wyników:

    • Flame Chart (Wykres płomienia) - pokazuje hierarchię renderowanych komponentów i czas ich renderowania
    • Ranked Chart (Wykres rankingowy) - sortuje komponenty według czasu renderowania
    • Component Chart (Wykres komponentów) - pokazuje, które komponenty zostały przerenderowane w każdej aktualizacji

Interpretacja kolorów w Profilerze:

  • Szary - komponent nie renderował się podczas aktualizacji
  • Żółty/Pomarańczowy/Czerwony - komponent renderował się, a kolor wskazuje, jak długo to trwało (im bardziej czerwony, tym dłużej)
  • Czarny - komponent był przyczyną aktualizacji (np. przez zmianę stanu)

2. Chrome Performance Panel

Chrome DevTools zawiera panel Performance, który pozwala na bardziej ogólne profilowanie wydajności strony:

  1. Uruchomienie profilowania:

    • Otwórz DevTools w Chrome (F12)
    • Przejdź do zakładki "Performance"
    • Kliknij przycisk nagrywania
    • Wykonaj akcje w aplikacji
    • Zatrzymaj nagrywanie
  2. Analizuj wyniki:

    • Main - pokazuje aktywność w głównym wątku (gdzie dzieje się większość pracy JS)
    • Frames - pokazuje ilość klatek na sekundę (FPS)
    • Network - pokazuje aktywność sieciową
    • Memory - pokazuje zużycie pamięci

Ten panel jest szczególnie przydatny do identyfikacji:

  • Długo działających skryptów blokujących główny wątek
  • Nadmiernych operacji na DOM
  • Problemów z wydajnością renderowania

3. Wbudowane API profilowania w React

React dostarcza wbudowane API do profilowania w trybie deweloperskim:

// Importujemy komponent Profiler
import { Profiler } from 'react';

// Funkcja callback wywoływana po renderowaniu
function onRenderCallback(
  id, // identyfikator profilowanego drzewa komponentów
  phase, // "mount" (pierwsze renderowanie) lub "update" (przerenderowanie)
  actualDuration, // czas spędzony na renderowaniu
  baseDuration, // szacowany czas renderowania całego poddrzewa bez optymalizacji
  startTime, // kiedy React rozpoczął renderowanie
  commitTime, // kiedy React zakończył renderowanie
  interactions // zestaw "interakcji" śledzonych dla tego renderowania
) {
  console.log({
    id,
    phase,
    actualDuration,
    baseDuration,
    startTime,
    commitTime
  });
}

// Użycie komponentu Profiler w aplikacji
function App() {
  return (
    <Profiler id="MissionControl" onRender={onRenderCallback}>
      <MissionControl />
    </Profiler>
  );
}

Możesz zagnieżdżać komponenty Profiler, aby profilować różne części aplikacji:

function Dashboard() {
  return (
    <Profiler id="Dashboard" onRender={onRenderCallback}>
      <h1>Panel kontrolny misji</h1>

      <Profiler id="Navigation" onRender={onRenderCallback}>
        <Navigation />
      </Profiler>

      <Profiler id="Stats" onRender={onRenderCallback}>
        <MissionStats />
      </Profiler>

      <Profiler id="Crew" onRender={onRenderCallback}>
        <CrewStatus />
      </Profiler>
    </Profiler>
  );
}

Ten sposób profilowania jest szczególnie przydatny, gdy:

  • Chcesz zbierać dane wydajnościowe w środowisku testowym
  • Masz specyficzne komponenty, które chcesz monitorować
  • Chcesz zautomatyzować zbieranie danych wydajnościowych

Typowe problemy wydajnościowe i ich profilowanie

1. Zbyt częste renderowanie komponentów

Problem: Komponenty renderują się ponownie, nawet gdy ich dane nie zmieniły się.

Jak profilować:

  • Użyj React DevTools Profiler, aby zobaczyć, które komponenty renderują się zbyt często
  • Sprawdź, czy komponenty rodzice nie powodują niepotrzebnych renderowań potomków

Przykład problemu:

function ParentComponent() {
  const [count, setCount] = useState(0);

  // Ta funkcja jest tworzona na nowo przy każdym renderowaniu
  const handleClick = () => {
    console.log('Button clicked');
  };

  return (
    <div>
      <button onClick={() => setCount(count + 1)}>
        Zwiększ licznik: {count}
      </button>

      {/* ChildComponent będzie renderowany ponownie przy każdej zmianie count,
          nawet jeśli handleClick ma taką samą funkcjonalność */}
      <ChildComponent onClick={handleClick} />
    </div>
  );
}

Rozwiązanie:

function ParentComponent() {
  const [count, setCount] = useState(0);

  // Memoizacja funkcji zapobiega tworzeniu nowej referencji przy każdym renderowaniu
  const handleClick = useCallback(() => {
    console.log('Button clicked');
  }, []);

  return (
    <div>
      <button onClick={() => setCount(count + 1)}>
        Zwiększ licznik: {count}
      </button>

      {/* ChildComponent owinięty w React.memo nie renderuje się ponownie,
          gdy jego propsy nie zmieniają się */}
      <MemoizedChildComponent onClick={handleClick} />
    </div>
  );
}

const MemoizedChildComponent = React.memo(ChildComponent);

2. Ciężkie obliczenia w renderowaniu

Problem: Wykonywanie skomplikowanych obliczeń podczas renderowania powoduje opóźnienia w UI.

Jak profilować:

  • Obserwuj w React DevTools Profiler komponenty, które mają najdłuższy czas renderowania
  • Użyj Chrome Performance Panel, aby zobaczyć długie zadania JavaScript

Przykład problemu:

function DataAnalytics({ data }) {
  // Ciężkie obliczenia wykonywane przy każdym renderowaniu
  const processedData = processLargeDataset(data);
  const statistics = calculateStatistics(processedData);

  return (
    <div>
      <h2>Analiza danych misji</h2>
      <DataVisualisation stats={statistics} />
    </div>
  );
}

Rozwiązanie:

function DataAnalytics({ data }) {
  // Memoizacja ciężkich obliczeń - wykonują się tylko gdy data się zmienia
  const processedData = useMemo(() => {
    return processLargeDataset(data);
  }, [data]);

  const statistics = useMemo(() => {
    return calculateStatistics(processedData);
  }, [processedData]);

  return (
    <div>
      <h2>Analiza danych misji</h2>
      <DataVisualisation stats={statistics} />
    </div>
  );
}

3. Nadmierne aktualizacje stanu

Problem: Zbyt częste aktualizacje stanu powodują kaskadowe rerenderowania.

Jak profilować:

  • W React DevTools Profiler znajdź komponenty oznaczone na czarno (inicjatorzy aktualizacji)
  • Obserwuj wzorce aktualizacji - czy niektóre komponenty aktualizują się w grupach?

Przykład problemu:

function SpaceshipSensors() {
  const [temperature, setTemperature] = useState(0);
  const [pressure, setPressure] = useState(0);
  const [oxygen, setOxygen] = useState(0);
  const [radiation, setRadiation] = useState(0);

  // Pobieranie danych z czujników co 100ms
  useEffect(() => {
    const interval = setInterval(() => {
      // Każda aktualizacja powoduje osobne renderowanie
      setTemperature(getTemperature());
      setPressure(getPressure());
      setOxygen(getOxygen());
      setRadiation(getRadiation());
    }, 100);

    return () => clearInterval(interval);
  }, []);

  return (
    <div>
      <h2>Odczyty czujników</h2>
      <p>Temperatura: {temperature}°C</p>
      <p>Ciśnienie: {pressure} hPa</p>
      <p>Poziom tlenu: {oxygen}%</p>
      <p>Poziom radiacji: {radiation} μSv/h</p>
    </div>
  );
}

Rozwiązanie:

function SpaceshipSensors() {
  // Przechowywanie powiązanych danych razem w jednym obiekcie stanu
  const [sensorData, setSensorData] = useState({
    temperature: 0,
    pressure: 0,
    oxygen: 0,
    radiation: 0
  });

  useEffect(() => {
    const interval = setInterval(() => {
      // Jedna aktualizacja stanu zamiast czterech
      setSensorData({
        temperature: getTemperature(),
        pressure: getPressure(),
        oxygen: getOxygen(),
        radiation: getRadiation()
      });
    }, 100);

    return () => clearInterval(interval);
  }, []);

  return (
    <div>
      <h2>Odczyty czujników</h2>
      <p>Temperatura: {sensorData.temperature}°C</p>
      <p>Ciśnienie: {sensorData.pressure} hPa</p>
      <p>Poziom tlenu: {sensorData.oxygen}%</p>
      <p>Poziom radiacji: {sensorData.radiation} μSv/h</p>
    </div>
  );
}

4. Duże listy i wizualizacje danych

Problem: Renderowanie długich list lub skomplikowanych wizualizacji może spowalniać interfejs.

Jak profilować:

  • Użyj React DevTools Profiler, aby zidentyfikować komponenty list, które długo się renderują
  • Sprawdź, jak często renderują się poszczególne elementy listy

Przykład użycia React DevTools do profilowania wydajności listy:

  1. Uruchom profilowanie
  2. Przewiń listę, aby zobaczyć, jak reaguje aplikacja
  3. Zatrzymaj profilowanie
  4. Sprawdź, które komponenty mają najdłuższy czas renderowania w wykresie rankingowym

Rozwiązanie:

  • Wirtualizacja list (React Window, React Virtualized)
  • Memoizacja elementów listy
  • Paginacja zamiast wyświetlania wszystkich elementów naraz

Zaawansowane techniki profilowania

1. User Timing API

Browser Performance API pozwala na tworzenie własnych znaczników czasowych:

function ExpensiveComponent({ data }) {
  useEffect(() => {
    // Początek pomiaru
    performance.mark('expensive-calculation-start');

    // Wykonanie kosztownych obliczeń
    const result = performExpensiveCalculation(data);

    // Koniec pomiaru
    performance.mark('expensive-calculation-end');

    // Utworzenie pomiaru między znacznikami
    performance.measure(
      'expensive-calculation',
      'expensive-calculation-start',
      'expensive-calculation-end'
    );

    // Logowanie wyników
    console.log(performance.getEntriesByName('expensive-calculation'));
  }, [data]);

  //
}

Te znaczniki będą widoczne w panelu Performance w Chrome DevTools.

2. Monitorowanie wydajności w środowisku produkcyjnym

Dla monitorowania wydajności w produkcji można użyć:

  • Web Vitals - biblioteka Google do pomiaru kluczowych wskaźników wydajności
  • New Relic, Datadog, Sentry - narzędzia APM (Application Performance Monitoring)
  • Własne rozwiązania korzystające z Performance API i Profiler API

Przykład zbierania danych z React Profiler i wysyłania ich na serwer:

function onRenderCallback(id, phase, actualDuration, baseDuration, startTime, commitTime) {
  // Zbieramy tylko dane z fazy commit i trwające dłużej niż 10ms
  if (phase === 'update' && actualDuration > 10) {
    sendToAnalyticsServer({
      componentId: id,
      renderTime: actualDuration,
      timestamp: Date.now()
    });
  }
}

function App() {
  return (
    <Profiler id="App" onRender={onRenderCallback}>
      <AppContent />
    </Profiler>
  );
}

Studium przypadku: Profilowanie i optymalizacja aplikacji React

Przeanalizujmy proces profilowania i optymalizacji wydajności aplikacji React na przykładzie panelu kontrolnego misji kosmicznej:

Krok 1: Identyfikacja problemu

Użytkownicy zgłaszają, że panel kontrolny działa wolno, szczególnie podczas wyświetlania danych telemetrycznych i listy zdarzeń.

Krok 2: Profilowanie aplikacji

Używamy React DevTools Profiler, aby zidentyfikować źródło problemu:

  1. Nagrywamy sesję podczas normalnego użytkowania panelu
  2. Analizujemy wyniki w Profilerze
  3. Odkrywamy, że:
    • Komponent TelemetryChart renderuje się bardzo długo (>100ms)
    • Komponent EventsList renderuje się za każdym razem, gdy przychodzą nowe dane telemetryczne
    • Funkcja calculateTrends zajmuje dużo czasu procesora

Krok 3: Optymalizacja

Na podstawie wyników profilowania wprowadzamy następujące optymalizacje:

  1. Optymalizacja TelemetryChart:
// Przed optymalizacją
function TelemetryChart({ data }) {
  // Ciężkie przetwarzanie danych przy każdym renderowaniu
  const chartData = processChartData(data);

  return <LineChart data={chartData} />;
}

// Po optymalizacji
const TelemetryChart = React.memo(function TelemetryChart({ data }) {
  // Memoizacja przetwarzania danych
  const chartData = useMemo(() => processChartData(data), [data]);

  return <LineChart data={chartData} />;
});
  1. Optymalizacja EventsList:
// Przed optymalizacją
function EventsList({ events }) {
  return (
    <div>
      {events.map(event => (
        <EventItem key={event.id} event={event} />
      ))}
    </div>
  );
}

// Po optymalizacji
const EventsList = React.memo(function EventsList({ events }) {
  return (
    <div>
      {events.map(event => (
        <MemoizedEventItem key={event.id} event={event} />
      ))}
    </div>
  );
});

const MemoizedEventItem = React.memo(EventItem);
  1. Przeniesienie ciężkich obliczeń do web workera:
// Przed optymalizacją
function MissionControlPanel({ telemetryData }) {
  const trends = calculateTrends(telemetryData);  // Blokuje główny wątek

  return (
    <div>
      <TrendsDisplay trends={trends} />
      {/* inne komponenty */}
    </div>
  );
}

// Po optymalizacji
function MissionControlPanel({ telemetryData }) {
  const [trends, setTrends] = useState(null);

  useEffect(() => {
    if (!telemetryData) return;

    // Utworzenie web workera
    const worker = new Worker('./trendsWorker.js');

    // Nasłuchiwanie odpowiedzi
    worker.addEventListener('message', (event) => {
      setTrends(event.data);
      worker.terminate();
    });

    // Wysłanie danych do przetworzenia
    worker.postMessage(telemetryData);
  }, [telemetryData]);

  return (
    <div>
      {trends ? <TrendsDisplay trends={trends} /> : <LoadingSpinner />}
      {/* inne komponenty */}
    </div>
  );
}

Krok 4: Weryfikacja optymalizacji

Po wprowadzeniu optymalizacji ponownie profilujemy aplikację:

  1. Czas renderowania TelemetryChart spadł z >100ms do ~15ms
  2. Komponent EventsList nie renderuje się już przy aktualizacjach danych telemetrycznych
  3. Główny wątek nie jest już blokowany przez calculateTrends

Dzięki tym optymalizacjom interfejs użytkownika działa płynnie, a panel kontrolny reaguje natychmiast na interakcje użytkownika.

Najlepsze praktyki profilowania

  1. Profiluj w środowisku podobnym do produkcyjnego

    • Uruchamiaj aplikację w trybie produkcyjnym (npm run build i serwuj zbudowane pliki)
    • Testuj na urządzeniach podobnych do tych używanych przez użytkowników
  2. Ustal punkty odniesienia

    • Zmierz wydajność przed i po optymalizacjach
    • Określ konkretne cele wydajnościowe (np. czas pierwszego renderowania < 2s)
  3. Profiluj regularnie

    • Włącz profilowanie do cyklu rozwoju aplikacji
    • Monitoruj wydajność po wprowadzeniu większych zmian
  4. Koncentruj się na percepcji użytkownika

    • Priorytetyzuj optymalizacje, które mają największy wpływ na odczuwalną wydajność
    • Pamiętaj o kluczowych metrykach Web Vitals (LCP, FID, CLS)
  5. Dokumentuj wyniki profilowania

    • Zapisuj dane wydajnościowe przed i po optymalizacjach
    • Udostępniaj wiedzę i techniki optymalizacji zespołowi

Podsumowanie

Profilowanie wydajności jest niezbędnym elementem tworzenia wysokiej jakości aplikacji React. Podobnie jak inżynierowie kosmiczni monitorują każdy aspekt działania statku, tak i my powinniśmy stale analizować wydajność naszych aplikacji, aby zapewnić użytkownikom płynne i responsywne doświadczenie.

Najważniejsze punkty do zapamiętania:

  1. Używaj odpowiednich narzędzi - React DevTools Profiler, Chrome Performance Panel
  2. Identyfikuj wąskie gardła - znajdź komponenty, które renderują się zbyt często lub zbyt długo
  3. Stosuj odpowiednie techniki optymalizacji - memoizacja, unikanie zbędnych renderowań, wirtualizacja list
  4. Mierz skuteczność optymalizacji - porównuj wydajność przed i po zmianach
  5. Optymalizuj z umiarem - pamiętaj, że przedwczesna optymalizacja może prowadzić do nadmiernie skomplikowanego kodu

Dzięki tym technikom i narzędziom profilowania, będziesz w stanie tworzyć wydajne aplikacje React, które zapewnią doskonałe doświadczenie użytkownikom, nawet w najbardziej skomplikowanych interfejsach kosmicznego panelu kontrolnego.

Kod do tej lekcji: App.jsx
import React, { useState, useMemo, useCallback, useEffect, useRef, Profiler } from 'react';

// ============================================
// PROFILOWANIE WYDAJNOSCI REACT
// ============================================
// Ten przyklad demonstruje techniki optymalizacji
// i profilowania komponentow React.

// --- Callback do profilowania ---
function onRenderCallback(id, phase, actualDuration, baseDuration) {
  console.log(
    `[Profiler] ${id} | phase: ${phase} | actual: ${actualDuration.toFixed(2)}ms | base: ${baseDuration.toFixed(2)}ms`
  );
}

// --- Symulacja ciezkiego obliczenia ---
function expensiveCalculation(items) {
  let result = 0;
  for (let i = 0; i < items.length; i++) {
    for (let j = 0; j < 1000; j++) {
      result += Math.sqrt(items[i].value * j + 1);
    }
  }
  return result.toFixed(2);
}

// --- Komponent BEZ optymalizacji ---
function UnoptimizedChild({ label, onClick }) {
  const renderCount = useRef(0);
  renderCount.current += 1;

  return (
    <div style={childStyle}>
      <span>{label}</span>
      <span style={renderBadge}>{renderCount.current}x renderowany</span>
      <button onClick={onClick} style={btnStyle}>Kliknij</button>
    </div>
  );
}

// --- Komponent Z optymalizacja (React.memo) ---
const OptimizedChild = React.memo(function OptimizedChild({ label, onClick }) {
  const renderCount = useRef(0);
  renderCount.current += 1;

  return (
    <div style={{ ...childStyle, borderColor: '#4CAF50' }}>
      <span>{label}</span>
      <span style={{ ...renderBadge, background: '#4CAF50' }}>{renderCount.current}x renderowany</span>
      <button onClick={onClick} style={{ ...btnStyle, background: '#4CAF50' }}>Kliknij</button>
    </div>
  );
});

// --- Komponent listy z wirtualizacja (uproszczona) ---
function VirtualizedList({ items, itemHeight = 40, containerHeight = 200 }) {
  const [scrollTop, setScrollTop] = useState(0);
  const containerRef = useRef(null);

  const visibleStart = Math.floor(scrollTop / itemHeight);
  const visibleCount = Math.ceil(containerHeight / itemHeight) + 1;
  const visibleItems = items.slice(visibleStart, visibleStart + visibleCount);

  return (
    <div
      ref={containerRef}
      onScroll={(e) => setScrollTop(e.target.scrollTop)}
      style={{
        height: containerHeight, overflow: 'auto',
        background: '#0d1b2a', borderRadius: '8px', border: '1px solid #2a3f5f',
      }}
    >
      <div style={{ height: items.length * itemHeight, position: 'relative' }}>
        {visibleItems.map((item, i) => (
          <div
            key={item.id}
            style={{
              position: 'absolute', top: (visibleStart + i) * itemHeight,
              height: itemHeight, width: '100%', padding: '8px 12px',
              boxSizing: 'border-box', borderBottom: '1px solid #1b2838',
              color: '#e0e1dd', display: 'flex', alignItems: 'center',
            }}
          >
            {item.name} - wartosc: {item.value}
          </div>
        ))}
      </div>
    </div>
  );
}

// --- Glowna aplikacja ---
function App() {
  const [count, setCount] = useState(0);
  const [filterText, setFilterText] = useState('');
  const [showOptimized, setShowOptimized] = useState(false);

  // Generujemy liste 500 elementow
  const largeList = useMemo(() => {
    return Array.from({ length: 500 }, (_, i) => ({
      id: i,
      name: `Misja #${i + 1}`,
      value: Math.floor(Math.random() * 1000),
    }));
  }, []);

  // Filtrowanie z useMemo - obliczenia wykonuja sie tylko gdy dane sie zmienia
  const filteredItems = useMemo(() => {
    return largeList.filter((item) =>
      item.name.toLowerCase().includes(filterText.toLowerCase())
    );
  }, [largeList, filterText]);

  // Ciezkie obliczenie z memoizacja
  const expensiveResult = useMemo(() => {
    return expensiveCalculation(filteredItems.slice(0, 50));
  }, [filteredItems]);

  // Callback BEZ memoizacji (nowa referencja przy kazdym renderowaniu)
  const handleClickUnoptimized = () => {
    console.log('Klik bez memoizacji');
  };

  // Callback Z memoizacja (stabilna referencja)
  const handleClickOptimized = useCallback(() => {
    console.log('Klik z useCallback');
  }, []);

  return (
    <div style={appStyle}>
      <h1 style={{ color: '#ffd700', textAlign: 'center', marginBottom: '8px' }}>
        Profilowanie wydajnosci React
      </h1>
      <p style={{ textAlign: 'center', color: '#aaa', marginBottom: '20px' }}>
        Otworz konsole przegladarki, aby zobaczyc logi z Profilera
      </p>

      {/* Sekcja 1: React.memo + useCallback */}
      <Profiler id="MemoDemo" onRender={onRenderCallback}>
        <div style={sectionStyle}>
          <h2 style={headingStyle}>React.memo + useCallback</h2>
          <p style={{ color: '#aaa', marginBottom: '12px' }}>
            Kliknij "+1" i obserwuj, ktory komponent renderuje sie ponownie.
          </p>
          <div style={{ textAlign: 'center', marginBottom: '16px' }}>
            <span style={{ fontSize: '24px', marginRight: '12px' }}>Licznik: {count}</span>
            <button onClick={() => setCount((c) => c + 1)} style={btnAccent}>+1</button>
          </div>

          <div style={{ display: 'flex', gap: '12px', flexWrap: 'wrap' }}>
            <div style={{ flex: 1, minWidth: '220px' }}>
              <h3 style={{ color: '#ff6b6b' }}>Bez optymalizacji</h3>
              <UnoptimizedChild
                label="Komponent A"
                onClick={handleClickUnoptimized}
              />
            </div>
            <div style={{ flex: 1, minWidth: '220px' }}>
              <h3 style={{ color: '#4CAF50' }}>Z React.memo + useCallback</h3>
              <OptimizedChild
                label="Komponent B"
                onClick={handleClickOptimized}
              />
            </div>
          </div>
        </div>
      </Profiler>

      {/* Sekcja 2: useMemo na ciezkich obliczeniach */}
      <Profiler id="UseMemoDemo" onRender={onRenderCallback}>
        <div style={sectionStyle}>
          <h2 style={headingStyle}>useMemo - ciezkie obliczenia</h2>
          <p style={{ color: '#aaa', marginBottom: '12px' }}>
            Filtrowanie i obliczenia sa memoizowane - zmiana filtra przelicza wynik.
          </p>
          <input
            value={filterText}
            onChange={(e) => setFilterText(e.target.value)}
            placeholder="Filtruj misje..."
            style={inputStyle}
          />
          <p style={{ margin: '8px 0', color: '#ffd700' }}>
            Wynik obliczen: {expensiveResult} | Znaleziono: {filteredItems.length} misji
          </p>
        </div>
      </Profiler>

      {/* Sekcja 3: Wirtualizacja listy */}
      <Profiler id="VirtualizedListDemo" onRender={onRenderCallback}>
        <div style={sectionStyle}>
          <h2 style={headingStyle}>Wirtualizacja listy (500 elementow)</h2>
          <p style={{ color: '#aaa', marginBottom: '12px' }}>
            Tylko widoczne elementy sa renderowane - przewin liste.
          </p>
          <label style={{ display: 'flex', alignItems: 'center', gap: '8px', marginBottom: '12px', cursor: 'pointer' }}>
            <input
              type="checkbox"
              checked={showOptimized}
              onChange={() => setShowOptimized(!showOptimized)}
            />
            Pokaz wirtualizowana liste
          </label>

          {showOptimized ? (
            <VirtualizedList items={filteredItems} />
          ) : (
            <div style={{
              height: 200, overflow: 'auto', background: '#0d1b2a',
              borderRadius: '8px', border: '1px solid #2a3f5f',
            }}>
              {filteredItems.map((item) => (
                <div key={item.id} style={{
                  padding: '8px 12px', borderBottom: '1px solid #1b2838',
                  color: '#e0e1dd',
                }}>
                  {item.name} - wartosc: {item.value}
                </div>
              ))}
            </div>
          )}
        </div>
      </Profiler>

      {/* TODO: Dodaj sekcje porownujaca wydajnosc
          dwoch podejsc do aktualizacji stanu:
          1. Wiele osobnych useState (temperatura, cisnienie, tlen)
          2. Jeden useState z obiektem { temperature, pressure, oxygen }
          Uzyj komponentu Profiler do pomiaru roznic. */}
    </div>
  );
}

// --- Style ---
const appStyle = {
  background: '#0d1b2a', minHeight: '100vh', padding: '20px',
  fontFamily: 'Arial, sans-serif', color: '#e0e1dd',
};
const sectionStyle = {
  background: '#1b2838', borderRadius: '12px', padding: '20px',
  maxWidth: '700px', margin: '16px auto', border: '1px solid #2a3f5f',
};
const headingStyle = { color: '#00d4ff', marginBottom: '8px' };
const childStyle = {
  display: 'flex', alignItems: 'center', gap: '10px',
  padding: '10px', background: '#0d1b2a', borderRadius: '8px',
  border: '1px solid #ff6b6b', marginBottom: '8px',
};
const renderBadge = {
  background: '#ff6b6b', color: '#fff', padding: '2px 8px',
  borderRadius: '12px', fontSize: '12px',
};
const btnStyle = {
  marginLeft: 'auto', padding: '6px 14px', background: '#ff6b6b',
  color: '#fff', border: 'none', borderRadius: '6px', cursor: 'pointer',
};
const btnAccent = {
  padding: '8px 20px', background: '#ffd700', color: '#000',
  border: 'none', borderRadius: '8px', cursor: 'pointer', fontWeight: 'bold',
};
const inputStyle = {
  width: '100%', padding: '8px 12px', background: '#0d1b2a',
  border: '1px solid #2a3f5f', borderRadius: '6px', color: '#e0e1dd',
  fontSize: '14px', boxSizing: 'border-box',
};

export default App;

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. Co robi React.memo() i kiedy warto go stosować?

  2. 2. Do czego służy React Profiler w React DevTools?

Zadania praktyczne w grze

  • Edytor kodu

    Dynamiczne ładowanie modułów

  • Układanie w poziomie

    Ułóż składnię Suspense z fallback UI:

  • Układanie w pionie

    Uporządkuj strategie testowania według priorytetu:

  • Edytor kodu

    Custom hook useForm z walidacją

  1. PytanieReact.memo do optymalizacji
  2. PytanieReact Profiler
  3. Zadanie z kodemPraktyka: Code splitting
  4. Ułóż w kolejnościCode splitting z React.lazy
  5. Ułóż w kolejnościPriorytety strategii testowania
  6. Zadanie z kodemPraktyka: useForm hook z walidacją

Przydatne artykuły