Kurs JavaScript i React · Moduł 8: Zaawansowane wzorce React
Profilowanie wydajności
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:
Instalacja React DevTools
- Dla Chrome: React Developer Tools
- Dla Firefox: React Developer Tools
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
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:
Uruchomienie profilowania:
- Otwórz DevTools w Chrome (F12)
- Przejdź do zakładki "Performance"
- Kliknij przycisk nagrywania
- Wykonaj akcje w aplikacji
- Zatrzymaj nagrywanie
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:
- Uruchom profilowanie
- Przewiń listę, aby zobaczyć, jak reaguje aplikacja
- Zatrzymaj profilowanie
- 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:
- Nagrywamy sesję podczas normalnego użytkowania panelu
- Analizujemy wyniki w Profilerze
- Odkrywamy, że:
- Komponent
TelemetryChartrenderuje się bardzo długo (>100ms) - Komponent
EventsListrenderuje się za każdym razem, gdy przychodzą nowe dane telemetryczne - Funkcja
calculateTrendszajmuje dużo czasu procesora
- Komponent
Krok 3: Optymalizacja
Na podstawie wyników profilowania wprowadzamy następujące optymalizacje:
- 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} />;
});- 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);- 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ę:
- Czas renderowania
TelemetryChartspadł z >100ms do ~15ms - Komponent
EventsListnie renderuje się już przy aktualizacjach danych telemetrycznych - 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
Profiluj w środowisku podobnym do produkcyjnego
- Uruchamiaj aplikację w trybie produkcyjnym (
npm run buildi serwuj zbudowane pliki) - Testuj na urządzeniach podobnych do tych używanych przez użytkowników
- Uruchamiaj aplikację w trybie produkcyjnym (
Ustal punkty odniesienia
- Zmierz wydajność przed i po optymalizacjach
- Określ konkretne cele wydajnościowe (np. czas pierwszego renderowania < 2s)
Profiluj regularnie
- Włącz profilowanie do cyklu rozwoju aplikacji
- Monitoruj wydajność po wprowadzeniu większych zmian
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)
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:
- Używaj odpowiednich narzędzi - React DevTools Profiler, Chrome Performance Panel
- Identyfikuj wąskie gardła - znajdź komponenty, które renderują się zbyt często lub zbyt długo
- Stosuj odpowiednie techniki optymalizacji - memoizacja, unikanie zbędnych renderowań, wirtualizacja list
- Mierz skuteczność optymalizacji - porównuj wydajność przed i po zmianach
- 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. Co robi React.memo() i kiedy warto go stosować?
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ą