Kurs JavaScript i React · Moduł 5: useEffect i własne hooki

Memoizacja - React.memo, useMemo i useCallback

6 min czytania ·
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?

  1. Przy kosztownych obliczeniach
  2. Przy tworzeniu obiektów referencyjnych jako propsy dla komponentów potomnych
  3. 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ć

TechnikaZastosowanieKiedy używać
React.memoKomponentGdy komponent często otrzymuje te same propsy
useMemoWartośćPrzy kosztownych obliczeniach i złożonych strukturach danych
useCallbackFunkcjaGdy 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ć nieskuteczna

Mądrze korzystaj z memoizacji

  1. Nie optymalizuj przedwcześnie - używaj najpierw profilerów, aby zidentyfikować rzeczywiste problemy wydajnościowe
  2. Stosuj memoizację selektywnie - tylko tam, gdzie jest faktycznie potrzebna
  3. 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.memo dla komponentów, które często renderują się ponownie z tymi samymi propsami
  • Stosuj useMemo dla kosztownych obliczeń i tworzenia złożonych struktur danych
  • Wykorzystuj useCallback do 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ń:

  1. Ułóż w kolejnościSkładnia useMemo z funkcją obliczeniową

Przydatne artykuły