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

Wzorce projektowe i reużywalność logiki

14 min czytania ·
W tej lekcji5

W kosmicznej podróży przez świat Reacta, efektywne wykorzystanie zasobów jest kluczowe dla sukcesu misji. Podobnie jak inżynierowie kosmiczni używają sprawdzonych projektów dla różnych modułów statku kosmicznego, tak i my możemy korzystać z wzorców projektowych w React, aby maksymalizować reużywalność kodu i tworzyć bardziej skalowalne aplikacje.

Wzorce renderowania i kompozycji

1. Komponenty wysokiego rzędu (HOC)

Higher-Order Components (HOC) to funkcje, które przyjmują komponent i zwracają nowy, wzbogacony komponent. To wzorzec oparty na zasadzie kompozycji, a nie dziedziczenia.

// Prosty HOC dodający funkcjonalność śledzenia czasu
function withTimer(WrappedComponent) {
  return function WithTimer(props) {
    const [startTime] = useState(Date.now());
    const [currentTime, setCurrentTime] = useState(Date.now());

    useEffect(() => {
      const timer = setInterval(() => {
        setCurrentTime(Date.now());
      }, 1000);

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

    const elapsedTime = (currentTime - startTime) / 1000;

    return (
      <WrappedComponent
        {...props}
        elapsedTime={elapsedTime}
      />
    );
  };
}

// Użycie HOC
function MissionControl({ missionName, elapsedTime }) {
  return (
    <div className="mission-control">
      <h2>Misja: {missionName}</h2>
      <p>Czas trwania: {elapsedTime.toFixed(0)} sekund</p>
      {/* reszta komponentu */}
    </div>
  );
}

const MissionControlWithTimer = withTimer(MissionControl);

// Renderowanie wzbogaconego komponentu
function App() {
  return <MissionControlWithTimer missionName="Apollo" />;
}

2. Render Props

Render Props to wzorzec, w którym komponent otrzymuje funkcję, która mówi mu, co ma renderować. Dzięki temu logika może być współdzielona między komponentami.

function MouseTracker({ render }) {
  const [position, setPosition] = useState({ x: 0, y: 0 });

  useEffect(() => {
    function handleMouseMove(event) {
      setPosition({
        x: event.clientX,
        y: event.clientY
      });
    }

    window.addEventListener('mousemove', handleMouseMove);

    return () => {
      window.removeEventListener('mousemove', handleMouseMove);
    };
  }, []);

  return render(position);
}

// Użycie render props
function App() {
  return (
    <MouseTracker
      render={({ x, y }) => (
        <div className="space-map">
          <h2>Mapa gwiezdna</h2>
          <p>Współrzędne kursora: ({x}, {y})</p>
          <div
            className="space-ship"
            style={{
              position: 'absolute',
              left: x,
              top: y
            }}
          >
            ▲
          </div>
        </div>
      )}
    />
  );
}

3. Wzorzec Compound Components

Ten wzorzec pozwala tworzyć komponenty, które współpracują ze sobą, zachowując elastyczność i czytelność kodu.

function Spaceship({ children }) {
  const [power, setPower] = useState(0);
  const [shields, setShields] = useState(false);

  const contextValue = {
    power,
    setPower,
    shields,
    setShields
  };

  return (
    <SpaceshipContext.Provider value={contextValue}>
      <div className="spaceship">
        {children}
      </div>
    </SpaceshipContext.Provider>
  );
}

// Komponenty potomne
Spaceship.Engine = function Engine() {
  const { power, setPower } = useContext(SpaceshipContext);

  return (
    <div className="engine">
      <h3>Silnik</h3>
      <p>Moc: {power}%</p>
      <input
        type="range"
        min="0"
        max="100"
        value={power}
        onChange={e => setPower(Number(e.target.value))}
      />
    </div>
  );
};

Spaceship.Shields = function Shields() {
  const { shields, setShields } = useContext(SpaceshipContext);

  return (
    <div className="shields">
      <h3>Tarcze</h3>
      <button onClick={() => setShields(!shields)}>
        {shields ? 'Dezaktywuj' : 'Aktywuj'} tarcze
      </button>
      <p>Status: {shields ? 'Aktywne' : 'Nieaktywne'}</p>
    </div>
  );
};

// Użycie
function App() {
  return (
    <Spaceship>
      <h2>Panel kontrolny statku kosmicznego</h2>
      <Spaceship.Engine />
      <Spaceship.Shields />
    </Spaceship>
  );
}

Wzorce zarządzania stanem

1. Flux / Redux

Redux implementuje wzorzec Flux, który zakłada jednokierunkowy przepływ danych. Stan aplikacji jest przechowywany w jednym obiekcie (store), a modyfikacje stanu mogą nastąpić tylko przez emisję akcji, które są przetwarzane przez reduktory.

// Akcje
const ADD_CREWMEMBER = 'ADD_CREWMEMBER';
const REMOVE_CREWMEMBER = 'REMOVE_CREWMEMBER';

// Action creators
function addCrewmember(member) {
  return {
    type: ADD_CREWMEMBER,
    payload: member
  };
}

function removeCrewmember(id) {
  return {
    type: REMOVE_CREWMEMBER,
    payload: id
  };
}

// Reduktor
function crewReducer(state = [], action) {
  switch (action.type) {
    case ADD_CREWMEMBER:
      return [...state, action.payload];
    case REMOVE_CREWMEMBER:
      return state.filter(member => member.id !== action.payload);
    default:
      return state;
  }
}

// W komponencie z react-redux
function CrewManagement() {
  const crew = useSelector(state => state.crew);
  const dispatch = useDispatch();

  function handleAddCrewmember() {
    const newMember = {
      id: Date.now(),
      name: 'Nowy członek załogi',
      role: 'Kadet'
    };
    dispatch(addCrewmember(newMember));
  }

  return (
    <div>
      <h2>Zarządzanie załogą</h2>
      <button onClick={handleAddCrewmember}>Dodaj członka załogi</button>
      <ul>
        {crew.map(member => (
          <li key={member.id}>
            {member.name} - {member.role}
            <button onClick={() => dispatch(removeCrewmember(member.id))}>
              Usuń
            </button>
          </li>
        ))}
      </ul>
    </div>
  );
}

2. Context API

Context API pozwala na przekazywanie danych przez drzewo komponentów bez konieczności przekazywania props na każdym poziomie.

// Stworzenie kontekstu
const MissionContext = createContext();

// Provider
function MissionProvider({ children }) {
  const [mission, setMission] = useState({
    name: 'Apollo 11',
    status: 'W trakcie',
    crewMembers: [
      { id: 1, name: 'Neil Armstrong', role: 'Dowódca' },
      { id: 2, name: 'Buzz Aldrin', role: 'Pilot modułu księżycowego' },
      { id: 3, name: 'Michael Collins', role: 'Pilot modułu dowodzenia' }
    ]
  });

  function updateMissionStatus(newStatus) {
    setMission(prev => ({ ...prev, status: newStatus }));
  }

  function addCrewMember(member) {
    setMission(prev => ({
      ...prev,
      crewMembers: [...prev.crewMembers, member]
    }));
  }

  const value = {
    mission,
    updateMissionStatus,
    addCrewMember
  };

  return (
    <MissionContext.Provider value={value}>
      {children}
    </MissionContext.Provider>
  );
}

// Custom hook dla łatwiejszego użycia
function useMission() {
  const context = useContext(MissionContext);
  if (!context) {
    throw new Error('useMission must be used within a MissionProvider');
  }
  return context;
}

// Użycie w komponentach
function MissionDashboard() {
  const { mission } = useMission();

  return (
    <div>
      <h1>Misja: {mission.name}</h1>
      <p>Status: {mission.status}</p>
    </div>
  );
}

function MissionControl() {
  const { updateMissionStatus } = useMission();

  return (
    <div>
      <h2>Centrum kontroli misji</h2>
      <button onClick={() => updateMissionStatus('Zakończona pomyślnie')}>
        Zakończ misję
      </button>
      <button onClick={() => updateMissionStatus('Przerwana')}>
        Przerwij misję
      </button>
    </div>
  );
}

function CrewList() {
  const { mission, addCrewMember } = useMission();

  return (
    <div>
      <h2>Załoga misji</h2>
      <ul>
        {mission.crewMembers.map(member => (
          <li key={member.id}>
            {member.name} - {member.role}
          </li>
        ))}
      </ul>
      <button
        onClick={() =>
          addCrewMember({
            id: Date.now(),
            name: 'Nowy astronauta',
            role: 'Specjalista misji'
          })
        }
      >
        Dodaj członka załogi
      </button>
    </div>
  );
}

// Połączenie wszystkiego
function App() {
  return (
    <MissionProvider>
      <div className="mission-app">
        <MissionDashboard />
        <MissionControl />
        <CrewList />
      </div>
    </MissionProvider>
  );
}

3. Custom hooks dla stanu

Jak widzieliśmy w poprzednim module, custom hooki są potężnym narzędziem do enkapsulacji i ponownego wykorzystania logiki związanej ze stanem.

function useSpaceshipSystems() {
  const [engines, setEngines] = useState({
    mainEngine: { power: 0, status: 'offline' },
    leftThruster: { power: 0, status: 'offline' },
    rightThruster: { power: 0, status: 'offline' }
  });

  const [lifeSupportSystem, setLifeSupportSystem] = useState({
    oxygen: 100,
    temperature: 21,
    pressure: 1
  });

  function startEngine(engineName) {
    setEngines(prev => ({
      ...prev,
      [engineName]: {
        ...prev[engineName],
        status: 'online',
        power: 10
      }
    }));
  }

  function setEnginePower(engineName, power) {
    if (engines[engineName].status === 'offline') {
      console.warn(`Nie można ustawić mocy - silnik ${engineName} jest wyłączony`);
      return;
    }

    setEngines(prev => ({
      ...prev,
      [engineName]: {
        ...prev[engineName],
        power: Math.max(0, Math.min(100, power))
      }
    }));
  }

  function stopEngine(engineName) {
    setEngines(prev => ({
      ...prev,
      [engineName]: {
        ...prev[engineName],
        status: 'offline',
        power: 0
      }
    }));
  }

  function adjustLifeSupport({ oxygen, temperature, pressure }) {
    setLifeSupportSystem(prev => ({
      ...prev,
      ...(oxygen !== undefined ? { oxygen } : {}),
      ...(temperature !== undefined ? { temperature } : {}),
      ...(pressure !== undefined ? { pressure } : {})
    }));
  }

  return {
    engines,
    lifeSupportSystem,
    startEngine,
    setEnginePower,
    stopEngine,
    adjustLifeSupport
  };
}

// Użycie
function SpaceshipControls() {
  const {
    engines,
    lifeSupportSystem,
    startEngine,
    setEnginePower,
    stopEngine,
    adjustLifeSupport
  } = useSpaceshipSystems();

  return (
    <div className="spaceship-controls">
      <h2>Kontrola systemów statku</h2>

      <div className="engines-section">
        <h3>Silniki</h3>
        {Object.entries(engines).map(([name, engine]) => (
          <div key={name} className="engine-control">
            <h4>{formatEngineName(name)}</h4>
            <p>Status: {engine.status}</p>
            <p>Moc: {engine.power}%</p>

            {engine.status === 'offline' ? (
              <button onClick={() => startEngine(name)}>Start</button>
            ) : (
              <>
                <input
                  type="range"
                  min="0"
                  max="100"
                  value={engine.power}
                  onChange={e => setEnginePower(name, Number(e.target.value))}
                />
                <button onClick={() => stopEngine(name)}>Stop</button>
              </>
            )}
          </div>
        ))}
      </div>

      <div className="life-support">
        <h3>System podtrzymywania życia</h3>
        <p>Poziom tlenu: {lifeSupportSystem.oxygen}%</p>
        <p>Temperatura: {lifeSupportSystem.temperature}°C</p>
        <p>Ciśnienie: {lifeSupportSystem.pressure} atm</p>

        <div className="controls">
          <button
            onClick={() =>
              adjustLifeSupport({
                oxygen: lifeSupportSystem.oxygen + 5
              })
            }
          >
            Zwiększ poziom tlenu
          </button>
          <button
            onClick={() =>
              adjustLifeSupport({
                temperature: lifeSupportSystem.temperature - 1
              })
            }
          >
            Obniż temperaturę
          </button>
        </div>
      </div>
    </div>
  );
}

function formatEngineName(name) {
  return name
    .replace(/([A-Z])/g, ' $1')
    .replace(/^./, str => str.toUpperCase());
}

Wzorce komponentów UI

1. Container / Presentational Pattern

Ten wzorzec rozdziela logikę biznesową (kontener) od prezentacji (komponent prezentacyjny), co zwiększa reużywalność komponentów i ułatwia testowanie.

// Komponent kontenerowy - zajmuje się logiką i pobieraniem danych
function PlanetDataContainer({ planetId, children }) {
  const [planet, setPlanet] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    setLoading(true);

    fetch(`https://api.planets.com/${planetId}`)
      .then(response => {
        if (!response.ok) throw new Error('Nie udało się pobrać danych planety');
        return response.json();
      })
      .then(data => {
        setPlanet(data);
        setLoading(false);
      })
      .catch(err => {
        setError(err.message);
        setLoading(false);
      });
  }, [planetId]);

  // Wywołanie funkcji children z danymi
  return children({ planet, loading, error });
}

// Komponent prezentacyjny - zajmuje się tylko wyświetlaniem
function PlanetInfo({ planet, loading, error }) {
  if (loading) return <div>Ładowanie danych planety...</div>;
  if (error) return <div>Błąd: {error}</div>;
  if (!planet) return null;

  return (
    <div className="planet-info">
      <h2>{planet.name}</h2>
      <div className="planet-details">
        <p>Typ: {planet.type}</p>
        <p>Średnica: {planet.diameter} km</p>
        <p>Odległość od Słońca: {planet.distanceFromSun} mln km</p>
        <p>Okres orbitalny: {planet.orbitalPeriod} dni</p>
        <p>Temperatura powierzchni: {planet.surfaceTemperature}°C</p>
      </div>

      {planet.moons && planet.moons.length > 0 && (
        <div className="moons">
          <h3>Księżyce ({planet.moons.length}):</h3>
          <ul>
            {planet.moons.map(moon => (
              <li key={moon.id}>{moon.name}</li>
            ))}
          </ul>
        </div>
      )}
    </div>
  );
}

// Użycie
function SolarSystemExplorer() {
  const [selectedPlanet, setSelectedPlanet] = useState('earth');

  return (
    <div className="solar-system-explorer">
      <h1>Eksploracja Układu Słonecznego</h1>

      <div className="planet-selector">
        <label>Wybierz planetę: </label>
        <select
          value={selectedPlanet}
          onChange={e => setSelectedPlanet(e.target.value)}
        >
          <option value="mercury">Merkury</option>
          <option value="venus">Wenus</option>
          <option value="earth">Ziemia</option>
          <option value="mars">Mars</option>
          <option value="jupiter">Jowisz</option>
          <option value="saturn">Saturn</option>
          <option value="uranus">Uran</option>
          <option value="neptune">Neptun</option>
        </select>
      </div>

      <PlanetDataContainer planetId={selectedPlanet}>
        {({ planet, loading, error }) => (
          <PlanetInfo planet={planet} loading={loading} error={error} />
        )}
      </PlanetDataContainer>
    </div>
  );
}

2. Composition vs Inheritance

React preferuje kompozycję nad dziedziczeniem. Ten wzorzec pozwala tworzyć elastyczne komponenty poprzez zagnieżdżanie i przekazywanie props.

// Komponent bazowy - Karta
function Card({ title, children, footer, className }) {
  return (
    <div className={`card ${className || ''}`}>
      {title && <div className="card-header">{title}</div>}
      <div className="card-body">{children}</div>
      {footer && <div className="card-footer">{footer}</div>}
    </div>
  );
}

// Specjalizowane komponenty przy użyciu kompozycji
function MissionCard({ mission, onComplete }) {
  return (
    <Card
      title={<h3>{mission.name}</h3>}
      footer={
        <button onClick={() => onComplete(mission.id)}>
          Zakończ misję
        </button>
      }
      className="mission-card"
    >
      <p><strong>Cel:</strong> {mission.objective}</p>
      <p><strong>Status:</strong> {mission.status}</p>
      <p><strong>Postęp:</strong> {mission.progress}%</p>
      <div className="progress-bar">
        <div
          className="progress"
          style={{ width: `${mission.progress}%` }}
        />
      </div>
    </Card>
  );
}

function AstronautCard({ astronaut, onAssign }) {
  return (
    <Card
      title={<h3>{astronaut.name}</h3>}
      footer={
        <button onClick={() => onAssign(astronaut.id)}>
          Przydziel do misji
        </button>
      }
      className="astronaut-card"
    >
      <div className="astronaut-info">
        <img
          src={astronaut.avatar}
          alt={astronaut.name}
          className="astronaut-avatar"
        />
        <div>
          <p><strong>Ranga:</strong> {astronaut.rank}</p>
          <p><strong>Specjalizacja:</strong> {astronaut.specialization}</p>
          <p><strong>Misje:</strong> {astronaut.missionCount}</p>
        </div>
      </div>
    </Card>
  );
}

// Użycie
function Dashboard() {
  const missions = [
    { id: 1, name: 'Eksploracja Marsa', objective: 'Zbadać powierzchnię', status: 'W toku', progress: 65 },
    { id: 2, name: 'Stacja kosmiczna ISS', objective: 'Konserwacja modułów', status: 'Zaplanowana', progress: 0 }
  ];

  const astronauts = [
    { id: 1, name: 'Jan Kowalski', rank: 'Kapitan', specialization: 'Pilot', missionCount: 5, avatar: '/avatars/jk.png' },
    { id: 2, name: 'Anna Nowak', rank: 'Porucznik', specialization: 'Inżynier', missionCount: 3, avatar: '/avatars/an.png' }
  ];

  return (
    <div className="dashboard">
      <h1>Panel kontrolny centrum kosmicznego</h1>

      <section className="missions-section">
        <h2>Aktywne misje</h2>
        <div className="missions-grid">
          {missions.map(mission => (
            <MissionCard
              key={mission.id}
              mission={mission}
              onComplete={id => console.log(`Zakończono misję ${id}`)}
            />
          ))}
        </div>
      </section>

      <section className="astronauts-section">
        <h2>Dostępni astronauci</h2>
        <div className="astronauts-grid">
          {astronauts.map(astronaut => (
            <AstronautCard
              key={astronaut.id}
              astronaut={astronaut}
              onAssign={id => console.log(`Przydzielono astronautę ${id}`)}
            />
          ))}
        </div>
      </section>
    </div>
  );
}

3. Wzorzec Headless Components

Ten wzorzec rozdziela logikę zachowania komponentu od jego wyglądu, pozwalając na maksymalną elastyczność stylistyczną.

// Komponent bezgłowy (Headless) - zawiera tylko logikę, bez UI
function useTabControl(initialTab = 0) {
  const [activeTab, setActiveTab] = useState(initialTab);

  function activateTab(index) {
    setActiveTab(index);
  }

  return {
    activeTab,
    activateTab
  };
}

// Użycie z dowolnym UI
function MissionTabs() {
  const tabs = [
    { id: 'overview', label: 'Przegląd' },
    { id: 'crew', label: 'Załoga' },
    { id: 'timeline', label: 'Harmonogram' },
    { id: 'systems', label: 'Systemy' }
  ];

  const { activeTab, activateTab } = useTabControl();

  return (
    <div className="mission-tabs">
      <div className="tabs-header">
        {tabs.map((tab, index) => (
          <button
            key={tab.id}
            className={`tab-button ${activeTab === index ? 'active' : ''}`}
            onClick={() => activateTab(index)}
          >
            {tab.label}
          </button>
        ))}
      </div>

      <div className="tab-content">
        {activeTab === 0 && (
          <div className="overview-tab">
            <h3>Przegląd misji</h3>
            <p>Misja Apollo 11 była pierwszą załogową misją na Księżyc...</p>
          </div>
        )}

        {activeTab === 1 && (
          <div className="crew-tab">
            <h3>Załoga</h3>
            <ul>
              <li>Neil Armstrong - Dowódca</li>
              <li>Edwin "Buzz" Aldrin - Pilot modułu księżycowego</li>
              <li>Michael Collins - Pilot modułu dowodzenia</li>
            </ul>
          </div>
        )}

        {activeTab === 2 && (
          <div className="timeline-tab">
            <h3>Harmonogram</h3>
            <div className="timeline">
              <div className="timeline-event">
                <span className="date">16 lipca 1969</span>
                <span className="description">Start z Przylądka Kennedy'ego</span>
              </div>
              <div className="timeline-event">
                <span className="date">20 lipca 1969</span>
                <span className="description">Lądowanie na Księżycu</span>
              </div>
              <div className="timeline-event">
                <span className="date">21 lipca 1969</span>
                <span className="description">Pierwszy krok na Księżycu</span>
              </div>
              <div className="timeline-event">
                <span className="date">24 lipca 1969</span>
                <span className="description">Powrót na Ziemię</span>
              </div>
            </div>
          </div>
        )}

        {activeTab === 3 && (
          <div className="systems-tab">
            <h3>Systemy statku</h3>
            <p>Moduł dowodzenia: Columbia</p>
            <p>Moduł księżycowy: Eagle</p>
            <p>Rakieta nośna: Saturn V</p>
          </div>
        )}
      </div>
    </div>
  );
}

Wzorce optymalizacyjne

1. Memoizacja

Memoizacja pomaga unikać niepotrzebnych renderowań przez zapamiętywanie rezultatów kosztownych obliczeń.

// Memoizacja komponentu
const MemoizedTelemetryChart = React.memo(function TelemetryChart({ data }) {
  // Symulacja kosztownych obliczeń
  const processedData = useMemo(() => {
    console.log('Przetwarzanie danych telemetrycznych...');

    // Kosztowne przetwarzanie danych
    return data.map(point => ({
      x: new Date(point.timestamp).toLocaleTimeString(),
      y: calculateAverage(point.readings),
      anomaly: detectAnomaly(point.readings)
    }));
  }, [data]); // Recalculate only when data changes

  return (
    <div className="telemetry-chart">
      <h3>Wykres telemetrii</h3>
      <div className="chart-container">
        {/* Wykres z przetworzonymi danymi */}
        {processedData.map((point, index) => (
          <div
            key={index}
            className={`data-point ${point.anomaly ? 'anomaly' : ''}`}
            style={{
              height: `${point.y * 2}px`,
              backgroundColor: point.anomaly ? 'red' : 'blue'
            }}
            title={`${point.x}: ${point.y} ${point.anomaly ? '(anomalia)' : ''}`}
          />
        ))}
      </div>
    </div>
  );
}, (prevProps, nextProps) => {
  // Własna logika porównania props
  if (prevProps.data.length !== nextProps.data.length) {
    return false; // renderuj ponownie jeśli zmienił się rozmiar danych
  }

  // Porównaj tylko ostatnie 5 punktów danych
  const prevLastFive = prevProps.data.slice(-5);
  const nextLastFive = nextProps.data.slice(-5);

  for (let i = 0; i < 5; i++) {
    if (!prevLastFive[i] || !nextLastFive[i]) continue;

    if (
      prevLastFive[i].timestamp !== nextLastFive[i].timestamp ||
      !arraysEqual(prevLastFive[i].readings, nextLastFive[i].readings)
    ) {
      return false; // renderuj ponownie jeśli dane się różnią
    }
  }

  return true; // nie renderuj ponownie
});

// Funkcje pomocnicze
function calculateAverage(readings) {
  return readings.reduce((sum, val) => sum + val, 0) / readings.length;
}

function detectAnomaly(readings) {
  const avg = calculateAverage(readings);
  const threshold = avg * 1.5;
  return readings.some(val => val > threshold);
}

function arraysEqual(a, b) {
  if (a.length !== b.length) return false;
  for (let i = 0; i < a.length; i++) {
    if (a[i] !== b[i]) return false;
  }
  return true;
}

2. Wirtualizacja list

Dla dużych list danych, wirtualizacja pozwala renderować tylko te elementy, które są aktualnie widoczne na ekranie.

// Implementacja prostej wirtualizacji (w rzeczywistych aplikacjach
// warto użyć bibliotek jak react-window lub react-virtualized)
function VirtualizedAsteroidList({ asteroids, rowHeight = 50, visibleRows = 10 }) {
  const [scrollTop, setScrollTop] = useState(0);
  const containerRef = useRef();

  const totalHeight = asteroids.length * rowHeight;
  const startIndex = Math.floor(scrollTop / rowHeight);
  const endIndex = Math.min(
    startIndex + visibleRows + 1,
    asteroids.length
  );

  const visibleAsteroids = useMemo(() => {
    return asteroids.slice(startIndex, endIndex);
  }, [asteroids, startIndex, endIndex]);

  const handleScroll = useCallback(() => {
    if (containerRef.current) {
      setScrollTop(containerRef.current.scrollTop);
    }
  }, []);

  return (
    <div className="asteroids-list">
      <h2>Katalog asteroid</h2>
      <p>Liczba asteroid: {asteroids.length}</p>

      <div
        ref={containerRef}
        className="virtual-list-container"
        style={{ height: rowHeight * visibleRows, overflow: 'auto' }}
        onScroll={handleScroll}
      >
        <div
          className="total-height"
          style={{ height: totalHeight }}
        >
          <div
            className="visible-items"
            style={{
              transform: `translateY(${startIndex * rowHeight}px)`
            }}
          >
            {visibleAsteroids.map(asteroid => (
              <div
                key={asteroid.id}
                className="asteroid-item"
                style={{ height: rowHeight }}
              >
                <span className="name">{asteroid.name}</span>
                <span className="diameter">Średnica: {asteroid.diameter} km</span>
                <span className="distance">
                  Odległość: {asteroid.distance} mln km
                </span>
                <span
                  className={`hazard-level ${asteroid.hazardLevel}`}
                >
                  {formatHazardLevel(asteroid.hazardLevel)}
                </span>
              </div>
            ))}
          </div>
        </div>
      </div>
    </div>
  );
}

function formatHazardLevel(level) {
  switch (level) {
    case 'high': return 'Wysokie zagrożenie';
    case 'medium': return 'Średnie zagrożenie';
    case 'low': return 'Niskie zagrożenie';
    default: return 'Brak zagrożenia';
  }
}

3. Lazy loading

Leniwne ładowanie komponentów pozwala odroczyć ładowanie części aplikacji, dopóki nie są potrzebne, co może znacznie przyspieszyć inicjalne ładowanie aplikacji.

// Lazy loading komponentów
const LazyMarsExplorer = lazy(() => import('./MarsExplorer'));
const LazyJupiterMoons = lazy(() => import('./JupiterMoons'));
const LazySaturnRings = lazy(() => import('./SaturnRings'));

function SolarSystemExplorer() {
  const [activeSection, setActiveSection] = useState(null);

  return (
    <div className="solar-system-explorer">
      <h1>Eksploracja układu słonecznego</h1>

      <div className="planet-selector">
        <button onClick={() => setActiveSection('mars')}>
          Eksploracja Marsa
        </button>
        <button onClick={() => setActiveSection('jupiter')}>
          Księżyce Jowisza
        </button>
        <button onClick={() => setActiveSection('saturn')}>
          Pierścienie Saturna
        </button>
      </div>

      <Suspense fallback={<div className="loading">Ładowanie modułu eksploracji...</div>}>
        {activeSection === 'mars' && <LazyMarsExplorer />}
        {activeSection === 'jupiter' && <LazyJupiterMoons />}
        {activeSection === 'saturn' && <LazySaturnRings />}
      </Suspense>
    </div>
  );
}

Podsumowanie

Wzorce projektowe w React dostarczają sprawdzonych rozwiązań dla typowych problemów programistycznych. Pozwalają na tworzenie kodu, który jest:

  1. Reużywalny - komponenty i logikę można łatwo wykorzystać w różnych częściach aplikacji
  2. Testowalny - separacja obowiązków ułatwia pisanie testów
  3. Skalowalny - aplikacja może rosnąć bez drastycznego wzrostu złożoności
  4. Łatwy w utrzymaniu - jasna struktura i organizacja ułatwiają wprowadzanie zmian

W kosmicznej podróży przez React, wzorce te są jak sprawdzone trasy międzygwiezdne, które pozwalają dotrzeć do celu szybciej i bezpieczniej. Eksperymentuj z różnymi wzorcami i wybieraj te, które najlepiej pasują do konkretnych potrzeb Twojej aplikacji.

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

// Custom Hook: useLocalStorage
function useLocalStorage(key, initialValue) {
  // Stan do przechowywania wartości
  const [storedValue, setStoredValue] = useState(() => {
    try {
      const item = window.localStorage.getItem(key);
      return item ? JSON.parse(item) : initialValue;
    } catch (error) {
      console.log('Error reading localStorage:', error);
      return initialValue;
    }
  });

  // Funkcja do aktualizacji wartości
  const setValue = useCallback((value) => {
    setStoredValue((prev) => (value instanceof Function ? value(prev) : value));
  }, []);

  // Zapisz do localStorage przy każdej zmianie
  useEffect(() => {
    try {
      window.localStorage.setItem(key, JSON.stringify(storedValue));
    } catch (error) {
      console.log('Error saving to localStorage:', error);
    }
  }, [key, storedValue]);

  return [storedValue, setValue];
}

// Custom Hook: useToggle
function useToggle(initialValue = false) {
  const [value, setValue] = useState(initialValue);

  const toggle = useCallback(() => {
    setValue(v => !v);
  }, []);

  const setTrue = useCallback(() => {
    setValue(true);
  }, []);

  const setFalse = useCallback(() => {
    setValue(false);
  }, []);

  return { value, toggle, setTrue, setFalse };
}

// Custom Hook: useCounter
function useCounter(initialValue = 0, step = 1) {
  const [count, setCount] = useState(initialValue);

  const increment = useCallback(() => {
    setCount(c => c + step);
  }, [step]);

  const decrement = useCallback(() => {
    setCount(c => c - step);
  }, [step]);

  const reset = useCallback(() => {
    setCount(initialValue);
  }, [initialValue]);

  return { count, increment, decrement, reset, setCount };
}

// Demonstracja custom hooks
function CustomHooksDemo() {
  // useLocalStorage - przechowywanie ustawień
  const [username, setUsername] = useLocalStorage('username', '');
  const [settings, setSettings] = useLocalStorage('settings', {
    darkMode: true,
    notifications: true,
    language: 'pl'
  });

  // useToggle - przełączniki
  const darkMode = useToggle(settings.darkMode);
  const showPanel = useToggle(false);
  const isEditing = useToggle(false);

  // useCounter - liczniki
  const visits = useCounter(0);
  const score = useCounter(100, 10);

  // Efekt synchronizacji z localStorage
  useEffect(() => {
    setSettings(prev => ({ ...prev, darkMode: darkMode.value }));
  }, [darkMode.value, setSettings]);

  const containerStyle = {
    minHeight: '100vh',
    background: darkMode.value
      ? 'linear-gradient(135deg, #1a1a2e 0%, #16213e 100%)'
      : 'linear-gradient(135deg, #f5f7fa 0%, #c3cfe2 100%)',
    padding: '30px',
    fontFamily: "'Segoe UI', sans-serif",
    color: darkMode.value ? '#fff' : '#1a1a2e',
    transition: 'all 0.5s ease',
  };

  const cardStyle = {
    background: darkMode.value ? 'rgba(255,255,255,0.05)' : 'rgba(0,0,0,0.05)',
    borderRadius: '15px',
    padding: '25px',
    marginBottom: '25px',
    border: '1px solid ' + (darkMode.value ? 'rgba(255,255,255,0.1)' : 'rgba(0,0,0,0.1)'),
  };

  return (
    <div style={containerStyle}>
      <header style={{ textAlign: 'center', marginBottom: '40px' }}>
        <h1 style={{ color: '#00d4ff', fontSize: '2.5em' }}>
          Custom Hooks Demo
        </h1>
        <p style={{ opacity: 0.7 }}>Tworzenie własnych hooków w React</p>
      </header>

      <div style={{ maxWidth: '900px', margin: '0 auto' }}>
        {/* useLocalStorage Demo */}
        <div style={cardStyle}>
          <h2 style={{ color: '#ffd700', marginBottom: '20px' }}>
            useLocalStorage
          </h2>
          <p style={{ marginBottom: '15px' }}>
            Przechowuje dane w localStorage z automatyczną synchronizacją
          </p>

          <div style={{ marginBottom: '15px' }}>
            <label style={{ display: 'block', marginBottom: '5px' }}>
              Nazwa użytkownika (zapisana w localStorage):
            </label>
            <input
              type="text"
              value={username}
              onChange={(e) => setUsername(e.target.value)}
              placeholder="Wpisz swoją nazwę"
              style={{
                padding: '10px 15px',
                borderRadius: '8px',
                border: '2px solid #00d4ff',
                background: 'transparent',
                color: 'inherit',
                width: '300px',
              }}
            />
          </div>

          <p style={{ fontSize: '14px', opacity: 0.7 }}>
            Odśwież stronę - wartość zostanie zachowana!
          </p>
        </div>

        {/* useToggle Demo */}
        <div style={cardStyle}>
          <h2 style={{ color: '#ffd700', marginBottom: '20px' }}>
            useToggle
          </h2>

          <div style={{ display: 'flex', gap: '20px', flexWrap: 'wrap' }}>
            <div style={{ flex: '1', minWidth: '200px' }}>
              <p style={{ marginBottom: '10px' }}>Dark Mode:</p>
              <button
                onClick={darkMode.toggle}
                style={{
                  padding: '10px 20px',
                  background: darkMode.value ? '#4CAF50' : '#f44336',
                  color: 'white',
                  border: 'none',
                  borderRadius: '8px',
                  cursor: 'pointer',
                }}
              >
                {darkMode.value ? 'ON' : 'OFF'}
              </button>
            </div>

            <div style={{ flex: '1', minWidth: '200px' }}>
              <p style={{ marginBottom: '10px' }}>Show Panel:</p>
              <button
                onClick={showPanel.toggle}
                style={{
                  padding: '10px 20px',
                  background: showPanel.value ? '#4CAF50' : '#9e9e9e',
                  color: 'white',
                  border: 'none',
                  borderRadius: '8px',
                  cursor: 'pointer',
                }}
              >
                {showPanel.value ? 'Ukryj' : 'Pokaż'}
              </button>
              {showPanel.value && (
                <div style={{
                  marginTop: '15px',
                  padding: '15px',
                  background: 'rgba(0,212,255,0.1)',
                  borderRadius: '8px',
                }}>
                  Panel widoczny!
                </div>
              )}
            </div>
          </div>
        </div>

        {/* useCounter Demo */}
        <div style={cardStyle}>
          <h2 style={{ color: '#ffd700', marginBottom: '20px' }}>
            useCounter
          </h2>

          <div style={{ display: 'flex', gap: '40px', flexWrap: 'wrap' }}>
            <div>
              <p style={{ marginBottom: '10px' }}>Visits (step: 1):</p>
              <div style={{ display: 'flex', alignItems: 'center', gap: '10px' }}>
                <button onClick={visits.decrement} style={btnStyle}>-</button>
                <span style={{ fontSize: '2em', minWidth: '60px', textAlign: 'center' }}>
                  {visits.count}
                </span>
                <button onClick={visits.increment} style={btnStyle}>+</button>
                <button onClick={visits.reset} style={{ ...btnStyle, background: '#ff9800' }}>
                  Reset
                </button>
              </div>
            </div>

            <div>
              <p style={{ marginBottom: '10px' }}>Score (step: 10):</p>
              <div style={{ display: 'flex', alignItems: 'center', gap: '10px' }}>
                <button onClick={score.decrement} style={btnStyle}>-10</button>
                <span style={{ fontSize: '2em', minWidth: '80px', textAlign: 'center' }}>
                  {score.count}
                </span>
                <button onClick={score.increment} style={btnStyle}>+10</button>
                <button onClick={score.reset} style={{ ...btnStyle, background: '#ff9800' }}>
                  Reset
                </button>
              </div>
            </div>
          </div>
        </div>
      </div>

      <footer style={{ textAlign: 'center', marginTop: '40px', opacity: 0.7 }}>
        <p>Custom hooks pozwalają na wydzielenie i współdzielenie logiki</p>
      </footer>
    </div>
  );
}

const btnStyle = {
  padding: '10px 20px',
  background: '#00d4ff',
  color: '#000',
  border: 'none',
  borderRadius: '8px',
  cursor: 'pointer',
  fontWeight: 'bold',
  fontSize: '16px',
};

export default CustomHooksDemo;

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. Które z poniższych jest zasadą korzystania z hooks?

  2. 2. Czym charakteryzuje się wzorzec Render Props?

To 2 z 4 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Custom hook dla stacji kosmicznej

  • Układanie w poziomie

    Ułóż składnię wywołania Higher-Order Component:

  • Układanie w pionie

    Uporządkuj strukturę custom hook:

  • Edytor kodu

    Zaawansowany data fetching hook

  • Edytor kodu

    HOC z autoryzacją i monitoringiem

  • Klikanie w kolejności

    Ułóż poprawną składnię Higher-Order Component:

  • Edytor kodu

    Render Props dla sieci sensorów

  1. PytanieWprowadzenie: Zasady hooków
  2. Zadanie z kodemPraktyka: Custom hook
  3. Ułóż w kolejnościWprowadzenie: Higher Order Components (HOC)
  4. Ułóż w kolejnościPrzepływ wzorców własnych hooków
  5. Zadanie z kodemPraktyka: useFetch hook
  6. PytanieWprowadzenie: Wzorzec Render Props
  7. PytanieWprowadzenie: Compound Components
  8. Zadanie z kodemWprowadzenie: Praktyka: Wzorzec HOC
  9. Kliknij w kolejnościWprowadzenie: Składnia HOC w React
  10. PytanieContainer vs Presentational
  11. Zadanie z kodemWprowadzenie: Praktyka: Render props

Przydatne artykuły