Kurs JavaScript i React · Moduł 5: useEffect i własne hooki
Memoizacja - React.memo, useMemo i useCallback
W tej lekcji8
W przestrzeni kosmicznej, zasoby są ograniczone i trzeba je mądrze wykorzystywać. Podobnie w świecie React, wydajność aplikacji ma kluczowe znaczenie. Memoizacja to technika optymalizacyjna, która pozwala na "zapamiętywanie" wyników kosztownych operacji i ponowne ich wykorzystanie, gdy wejściowe dane nie uległy zmianie - podobnie jak zapisywanie i wykorzystywanie obliczeń trajektorii kosmicznej zamiast wykonywania ich od nowa.
Czym jest memoizacja w React?
Memoizacja w React to mechanizm optymalizacji wydajności, który pozwala:
- Unikać niepotrzebnych ponownych renderowań komponentów
- Zapobiegać ponownemu wykonywaniu kosztownych obliczeń
- Stabilizować referencje do funkcji i obiektów
React.memo - memoizacja komponentów
React.memo to komponent wyższego rzędu (HOC), który opakowuje komponent i zapobiega jego ponownemu renderowaniu, jeśli jego propsy nie uległy zmianie.
Podstawowe użycie React.memo
import React from 'react';
// Komponent bez memoizacji
function PlanetInfo({ name, diameter, distance }) {
console.log(`Renderowanie informacji o planecie: ${name}`);
return (
<div className="planet-info">
<h2>{name}</h2>
<p>Średnica: {diameter} km</p>
<p>Odległość od Słońca: {distance} mln km</p>
</div>
);
}
// Ten sam komponent z memoizacją
const MemoizedPlanetInfo = React.memo(PlanetInfo);
// Komponent rodzic
function SolarSystem() {
const [count, setCount] = useState(0);
return (
<div>
<button onClick={() => setCount(count + 1)}>
Licznik: {count}
</button>
{/* Ten komponent będzie renderowany ponownie tylko gdy jego propsy się zmienią */}
<MemoizedPlanetInfo
name="Mars"
diameter={6779}
distance={228}
/>
</div>
);
}Zauważ, że w powyższym przykładzie, mimo że komponent nadrzędny SolarSystem renderuje się ponownie przy każdym kliknięciu przycisku, komponent MemoizedPlanetInfo nie będzie ponownie renderowany, ponieważ jego propsy pozostają niezmienione.
Niestandardowe porównanie propsów
Domyślnie React.memo porównuje propsy za pomocą płytkiego porównania (shallow comparison). Możesz jednak dostarczyć własną funkcję porównującą:
const MemoizedPlanetInfo = React.memo(
PlanetInfo,
(prevProps, nextProps) => {
// Zwróć true, jeśli chcesz zapobiec ponownemu renderowaniu
// Zwróć false, jeśli chcesz ponownie wyrenderować komponent
return prevProps.name === nextProps.name &&
prevProps.diameter === nextProps.diameter;
// Zauważ, że ignorujemy zmianę distance - komponent nie wyrenderuje się ponownie
// kiedy zmieni się tylko ta właściwość
}
);useMemo - memoizacja wartości
Hook useMemo pozwala na zapamiętanie wyniku kosztownej operacji i ponowne użycie go, o ile zależności nie uległy zmianie.
Kiedy używać useMemo?
- Przy kosztownych obliczeniach
- Przy tworzeniu obiektów referencyjnych jako propsy dla komponentów potomnych
- Przy tworzeniu obszernych struktur danych
import React, { useState, useMemo } from 'react';
function AsteroidCalculator({ asteroids }) {
const [filter, setFilter] = useState('all');
// Kosztowne obliczenie - memoizowane dla lepszej wydajności
const dangerousAsteroids = useMemo(() => {
console.log('Obliczanie niebezpiecznych asteroid...');
return asteroids.filter(asteroid => {
// Symulacja kosztownych obliczeń
let isDangerous = false;
for (let i = 0; i < 10000; i++) {
if (asteroid.velocity > 20 && asteroid.size > 1000 && asteroid.distance < 50000000) {
isDangerous = true;
}
}
return isDangerous;
});
}, [asteroids]); // Obliczenie zostanie wykonane ponownie tylko gdy zmieni się tablica asteroids
// To obliczenie również jest memoizowane, ale zależy od filtru
const displayedAsteroids = useMemo(() => {
console.log('Filtrowanie asteroid...');
if (filter === 'all') return asteroids;
if (filter === 'dangerous') return dangerousAsteroids;
return [];
}, [filter, asteroids, dangerousAsteroids]);
return (
<div>
<div>
<button onClick={() => setFilter('all')}>Wszystkie</button>
<button onClick={() => setFilter('dangerous')}>Niebezpieczne</button>
</div>
<h2>Asteroidy ({displayedAsteroids.length}):</h2>
<ul>
{displayedAsteroids.map(asteroid => (
<li key={asteroid.id}>{asteroid.name}</li>
))}
</ul>
</div>
);
}useCallback - memoizacja funkcji
Hook useCallback jest podobny do useMemo, ale zamiast zapamiętywać wynik funkcji, zapamiętuje samą funkcję. Jest szczególnie przydatny, gdy przekazujesz funkcje jako propsy do memoizowanych komponentów potomnych.
import React, { useState, useCallback } from 'react';
function MissionControl() {
const [missionStatus, setMissionStatus] = useState('preparing');
const [fuelLevel, setFuelLevel] = useState(100);
// Z useCallback, funkcja jest tworzona ponownie tylko wtedy, gdy zmienia się fuelLevel
const startMission = useCallback(() => {
if (fuelLevel > 20) {
setMissionStatus('in-progress');
console.log(`Misja rozpoczęta z poziomem paliwa: ${fuelLevel}%`);
} else {
console.log('Za mało paliwa do rozpoczęcia misji');
}
}, [fuelLevel]); // Zależność: funkcja utworzona ponownie, gdy zmieni się fuelLevel
const abortMission = useCallback(() => {
setMissionStatus('aborted');
console.log('Misja przerwana!');
}, []); // Pusta tablica zależności - funkcja utworzona tylko raz
return (
<div>
<h2>Status misji: {missionStatus}</h2>
<p>Poziom paliwa: {fuelLevel}%</p>
<button onClick={() => setFuelLevel(prev => Math.max(0, prev - 10))}>
Zużyj paliwo
</button>
{/* Przekazanie memoizowanych funkcji jako propsów */}
<MemoizedControlPanel
onStart={startMission}
onAbort={abortMission}
fuelLevel={fuelLevel}
/>
</div>
);
}
// Memoizowany komponent potomny, który otrzymuje funkcje jako propsy
const ControlPanel = React.memo(({ onStart, onAbort, fuelLevel }) => {
console.log('Renderowanie panelu kontrolnego');
return (
<div className="control-panel">
<h3>Panel sterowania</h3>
<button onClick={onStart} disabled={fuelLevel <= 20}>
Start
</button>
<button onClick={onAbort}>
Przerwij misję
</button>
</div>
);
});
const MemoizedControlPanel = React.memo(ControlPanel);Porównanie technik memoizacji i kiedy ich używać
| Technika | Zastosowanie | Kiedy używać |
|---|---|---|
| React.memo | Komponent | Gdy komponent często otrzymuje te same propsy |
| useMemo | Wartość | Przy kosztownych obliczeniach i złożonych strukturach danych |
| useCallback | Funkcja | Gdy przekazujesz funkcje jako propsy do memoizowanych komponentów |
Typowe błędy i pułapki
1. Nadmierna memoizacja
// Nieoptymalne - zbyt prosta wartość do memoizacji
const count = useMemo(() => 1 + 2, []);
// Nieoptymalne - prosta funkcja, która nie potrzebuje memoizacji
const handleClick = useCallback(() => {
console.log('Kliknięto!');
}, []);2. Zapominanie o zależnościach
// Niebezpieczne - brakuje zależności 'value'
const processedData = useMemo(() => {
return heavyProcessing(value);
}, []); // Powinno być [value]3. Zbyt wiele zależności
// Może zmniejszyć skuteczność memoizacji
const result = useMemo(() => {
return computeResult(a, b);
}, [a, b, c, d, e]); // Zbyt dużo zależności - memoizacja może być nieskutecznaMądrze korzystaj z memoizacji
- Nie optymalizuj przedwcześnie - używaj najpierw profilerów, aby zidentyfikować rzeczywiste problemy wydajnościowe
- Stosuj memoizację selektywnie - tylko tam, gdzie jest faktycznie potrzebna
- Pamiętaj o koszcie - memoizacja również ma swój koszt, który może przewyższać zyski dla prostszych operacji
Podsumowanie
Memoizacja w React to potężna technika optymalizacyjna, która - podobnie jak oszczędzanie zasobów na statku kosmicznym - pomaga efektywnie zarządzać wydajnością aplikacji. Korzystaj z niej mądrze:
- Używaj
React.memodla komponentów, które często renderują się ponownie z tymi samymi propsami - Stosuj
useMemodla kosztownych obliczeń i tworzenia złożonych struktur danych - Wykorzystuj
useCallbackdo stabilizowania referencji funkcji przekazywanych w dół drzewa komponentów
Pamiętaj jednak, że jak każda technika optymalizacyjna, memoizacja ma swój koszt i powinna być stosowana rozważnie, tam gdzie faktycznie przynosi korzyści wydajnościowe.
Kod do tej lekcji: App.jsx
import React, { useState, useMemo, useCallback, memo, useRef } from 'react';
// React.memo - memoizacja komponentów
const SpaceShip = memo(function SpaceShip({ name, speed, onSelect }) {
console.log(`Rendering SpaceShip: ${name}`);
return (
<div className="spaceship" onClick={() => onSelect(name)}>
<h3>{name}</h3>
<p>Prędkość: {speed} km/s</p>
</div>
);
});
// useMemo - memoizacja wartości
function ExpensiveCalculation({ numbers }) {
const [filter, setFilter] = useState('');
// useMemo zapobiega ponownemu obliczaniu przy każdym renderze
const stats = useMemo(() => {
console.log('Obliczanie statystyk...');
// Symulacja kosztownej operacji
const sum = numbers.reduce((a, b) => a + b, 0);
const avg = sum / numbers.length;
const max = Math.max(...numbers);
const min = Math.min(...numbers);
return { sum, avg, max, min };
}, [numbers]); // Tylko gdy numbers się zmieni
const filteredNumbers = useMemo(() => {
if (!filter) return numbers;
const threshold = parseInt(filter) || 0;
return numbers.filter(n => n >= threshold);
}, [numbers, filter]);
return (
<div className="demo-card">
<h2>useMemo - Statystyki</h2>
<div className="stats">
<div className="stat">Suma: {stats.sum}</div>
<div className="stat">Średnia: {stats.avg.toFixed(2)}</div>
<div className="stat">Min: {stats.min}</div>
<div className="stat">Max: {stats.max}</div>
</div>
<input
type="number"
value={filter}
onChange={(e) => setFilter(e.target.value)}
placeholder="Filtruj >= wartość"
/>
<div className="filtered">
Przefiltrowane: [{filteredNumbers.join(', ')}]
</div>
</div>
);
}
// useCallback - memoizacja funkcji
function SpaceFleet() {
const [ships] = useState([
{ name: 'Apollo', speed: 11 },
{ name: 'Voyager', speed: 17 },
{ name: 'Enterprise', speed: 299792 },
]);
const [selected, setSelected] = useState(null);
const [count, setCount] = useState(0);
// Bez useCallback - nowa funkcja przy każdym renderze
// const handleSelect = (name) => setSelected(name);
// Z useCallback - ta sama referencja funkcji
const handleSelect = useCallback((name) => {
setSelected(name);
}, []);
return (
<div className="demo-card">
<h2>useCallback - Flota</h2>
<p className="hint">Otwórz konsolę - zobacz które statki się re-renderują</p>
<div className="fleet">
{ships.map(ship => (
<SpaceShip
key={ship.name}
name={ship.name}
speed={ship.speed}
onSelect={handleSelect}
/>
))}
</div>
{selected && <p className="selected">Wybrano: {selected}</p>}
<div className="counter-section">
<button onClick={() => setCount(c => c + 1)}>
Licznik: {count} (powoduje re-render)
</button>
</div>
</div>
);
}
// Porównanie z i bez memoizacji
function MemoizationComparison() {
const [value, setValue] = useState(0);
const calls = useRef({ with: 0, without: 0 });
// Funkcja BEZ memoizacji
const expensiveWithout = () => {
calls.current.without += 1;
let result = 0;
for (let i = 0; i < 1000; i++) {
result += Math.sqrt(i);
}
return result;
};
// Funkcja Z memoizacją
const expensiveWith = useMemo(() => {
calls.current.with += 1;
let result = 0;
for (let i = 0; i < 1000; i++) {
result += Math.sqrt(i);
}
return result;
}, []); // Pusta tablica = oblicz raz
const resultWithout = expensiveWithout();
return (
<div className="demo-card">
<h2>Porównanie</h2>
<div className="comparison">
<div className="box without">
<h3>Bez useMemo</h3>
<p>Wywołań: {calls.current.without}</p>
<p className="result">{resultWithout.toFixed(2)}</p>
</div>
<div className="box with">
<h3>Z useMemo</h3>
<p>Wywołań: {calls.current.with}</p>
<p className="result">{expensiveWith.toFixed(2)}</p>
</div>
</div>
<button onClick={() => setValue(v => v + 1)}>
Wymuś re-render ({value})
</button>
</div>
);
}
function App() {
const [numbers] = useState([23, 45, 12, 67, 89, 34, 56, 78, 90, 11]);
return (
<div className="app">
<h1>Memoizacja w React</h1>
<p className="subtitle">React.memo, useMemo, useCallback</p>
<div className="demos">
<ExpensiveCalculation numbers={numbers} />
<SpaceFleet />
<MemoizationComparison />
</div>
</div>
);
}
export default App;Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż poprawną składnię useMemo do memoizacji obliczeń: