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

Projekt główny: Budowanie aplikacji produkcyjnej

6 min czytania ·
W tej lekcji7

Znasz już wiele osobnych narzędzi ale prawdziwa misja zaczyna się wtedy, gdy trzeba je złożyć w jeden statek. Każdy wzorzec z osobna wygląda prosto. Kłopot pojawia się w dużej aplikacji: gdzie trzymać logikę, jak dzielić się nią między ekranami i jak sprawdzić, że po zmianie nic się nie zepsuło. Ta lekcja odpowiada właśnie na te pytania.

Nadszedł moment kulminacyjny naszej kosmicznej wyprawy. Przez cały ten moduł poznawaliśmy zaawansowane wzorce i najlepsze praktyki React - od custom hooków, przez Higher-Order Components i render props, aż po compound components, testowanie i deployment. Teraz pora połączyć te wszystkie elementy w jeden spójny projekt: Centrum Dowodzenia Misją Kosmiczną.

Architektura projektu

Budując aplikację produkcyjną, kluczowe jest przemyślenie jej architektury. Nasz projekt łączy wzorce, które poznaliśmy w tym module. Zacznijmy od mapy pokładów, czyli struktury folderów:

// Struktura projektu
// src/
//   hooks/          - Custom hooki (useMission, useFuel, useCrewStatus)
//   components/     - Komponenty wielokrotnego użytku
//   hoc/            - Higher-Order Components (withAuth, withLogging)
//   context/        - Konteksty React (MissionContext, ThemeContext)
//   utils/          - Funkcje pomocnicze i walidacja
//   App.jsx         - Główny komponent aplikacji

Każdy folder to osobny pokład statku z jasno określonym zadaniem. Sam React nie narzuca takiego podziału, to nasza konwencja. Ważne, żeby cały zespół trzymał się jednej.

Custom Hooki - serce logiki biznesowej

Custom hooki pozwalają wydzielić logikę z komponentów i uczynić ją wielokrotnie używalną. W naszym projekcie każdy aspekt misji kosmicznej ma swój dedykowany hook. Hook useMission przechowuje dane misji i jej status w stanie oraz udostępnia funkcje zmieniające status:

// Custom hook do zarządzania misją
function useMission(initialMission) {
  const [mission, setMission] = useState(initialMission);
  const [status, setStatus] = useState('planning');

  const launch = () => {
    if (mission.fuel >= mission.requiredFuel) {
      setStatus('in-progress');
    }
  };

  const complete = () => setStatus('completed');
  const abort = () => setStatus('aborted');

  return { mission, status, launch, complete, abort };
}

Komponent, który użyje useMission, dostaje gotowe launch, complete i abort, nie wiedząc nic o useState w środku. Start misji zmienia status tylko wtedy, gdy paliwa jest co najmniej tyle, ile wymaga misja. W przeciwnym razie status zostaje planning.

Higher-Order Components i Render Props

HOC pozwalają na dodawanie funkcjonalności do komponentów bez modyfikacji ich kodu źródłowego. Higher-Order Component to funkcja, która przyjmuje komponent i zwraca nowy komponent z dodatkowymi propsami. Tutaj withLogging dokleja funkcję logAction:

// HOC - dodaje logowanie akcji
function withLogging(WrappedComponent) {
  return function LoggedComponent(props) {
    const logAction = (action) => {
      console.log(`[LOG] ${new Date().toISOString()}: ${action}`);
    };
    return <WrappedComponent {...props} logAction={logAction} />;
  };
}

Opakowany komponent działa jak wcześniej i dostaje tylko jeden nowy prop. Jego własny kod się nie zmienia.

Render props dają elastyczność w renderowaniu. Komponent z render prop trzyma dane u siebie, a to, co pokazać, oddaje funkcji przekazanej w propsie render:

// Render Props - udostępnia dane o paliwie
function FuelProvider({ render }) {
  const [fuel, setFuel] = useState(100);
  const consume = (amount) => setFuel(prev => Math.max(0, prev - amount));
  const refuel = (amount) => setFuel(prev => Math.min(100, prev + amount));
  return render({ fuel, consume, refuel });
}

FuelProvider pilnuje, żeby paliwo nie spadło poniżej 0 ani nie przekroczyło 100, ale nie decyduje o wyglądzie. Od wprowadzenia hooków w nowym kodzie większość zadań HOC i render props przejęły custom hooki. Oba wzorce warto jednak znać, bo spotkasz je w starszych bibliotekach i projektach.

Compound Components

Wzorzec compound components pozwala tworzyć komponenty, które działają razem jako spójny system. Najpierw rodzic, który trzyma wspólny stan rozwinięcia i przekazuje go dzieciom:

// Compound Component - Panel Misji
function MissionPanel({ children }) {
  const [isExpanded, setIsExpanded] = useState(false);
  return (
    <div className="mission-panel">
      {React.Children.map(children, child =>
        React.isValidElement(child)
          ? React.cloneElement(child, { isExpanded, setIsExpanded })
          : child
      )}
    </div>
  );
}

React.Children.map przechodzi po dzieciach, a React.cloneElement dokłada każdemu propsy isExpanded i setIsExpanded. Teraz części składowe panelu, przypięte jako właściwości MissionPanel:

MissionPanel.Header = function Header({ isExpanded, setIsExpanded, children }) {
  return (
    <div onClick={() => setIsExpanded(!isExpanded)} style={{ cursor: 'pointer' }}>
      {children} {isExpanded ? '▲' : '▼'}
    </div>
  );
};

MissionPanel.Body = function Body({ isExpanded, children }) {
  return isExpanded ? <div>{children}</div> : null;
};

Nagłówek przełącza stan, a treść pokazuje się tylko po rozwinięciu. Uwaga praktyczna: react.dev zalicza cloneElement do rzadko używanych API, bo łatwo je zepsuć, na przykład opakowując dziecko w dodatkowy div. W nowym kodzie polecam przekazywać wspólny stan przez kontekst (createContext i useContext), a cloneElement traktować jako wersję historyczną.

Testowanie - klucz do niezawodności

Kod produkcyjny musi być przetestowany. Każdy custom hook, komponent i funkcja pomocnicza powinny mieć odpowiednie testy. Hooki testujemy funkcją renderHook, a wywołania zmieniające stan opakowujemy w act. Obie funkcje pochodzą z pakietu @testing-library/react (dawny osobny pakiet @testing-library/react-hooks jest przestarzały):

// Przykładowy test custom hooka
// describe('useMission', () => {
//   it('powinien uruchomić misję, gdy jest wystarczająco paliwa', () => {
//     const { result } = renderHook(() =>
//       useMission({ fuel: 100, requiredFuel: 50 })
//     );
//     act(() => result.current.launch());
//     expect(result.current.status).toBe('in-progress');
//   });
//
//   it('nie powinien uruchomić misji bez paliwa', () => {
//     const { result } = renderHook(() =>
//       useMission({ fuel: 20, requiredFuel: 50 })
//     );
//     act(() => result.current.launch());
//     expect(result.current.status).toBe('planning');
//   });
// });

Pierwszy test sprawdza, że przy 100 jednostkach paliwa misja startuje, drugi, że przy 20 status zostaje planning. Uruchomiliśmy oba scenariusze i dają dokładnie te wyniki. Kod hooka nie musiał się zmienić, żeby dało się go przetestować.

Deployment i optymalizacja

Przed wdrożeniem aplikacji na produkcję upewnij się, że:

  1. Optymalizacja wydajności - użyj React.memo, useMemo i useCallback tam, gdzie to potrzebne
  2. Code splitting - podziel aplikację na mniejsze chunki za pomocą lazy() i Suspense
  3. Zmienne środowiskowe - przechowuj konfigurację w plikach .env
  4. Error boundaries - dodaj obsługę błędów na poziomie komponentów
  5. Build produkcyjny - uruchom npm run build i przetestuj wynik

Trzy doprecyzowania do tej listy. W projekcie Vite do kodu przeglądarki trafiają tylko zmienne z prefiksem VITE_, odczytywane przez import.meta.env, więc nigdy nie trzymaj w nich sekretów. Error boundary nadal pisze się jako komponent klasowy albo korzysta z biblioteki react-error-boundary. A wynik buildu obejrzysz lokalnie poleceniem npm run preview.

Podsumowanie modułu

W tym module poznałeś zaawansowane wzorce React, które są fundamentem profesjonalnego tworzenia aplikacji:

  • Custom Hooki - wydzielanie i współdzielenie logiki między komponentami
  • Higher-Order Components - dodawanie funkcjonalności przez kompozycję
  • Render Props - elastyczne renderowanie z przekazywaniem danych
  • Compound Components - tworzenie spójnych systemów komponentów
  • Testowanie - zapewnienie niezawodności kodu
  • Deployment - wdrażanie aplikacji na produkcję

Moja rada na koniec: zaczynaj od custom hooka, po HOC i render props sięgaj tylko wtedy, gdy wymaga tego biblioteka, i pisz test dla każdej logiki, która decyduje o losie misji. Po tej lekcji czeka cię projekt dla mentora, w którym złożysz wszystkie te wzorce w jedno laboratorium.

Te wzorce to Twój zestaw narzędzi kosmicznego inżyniera - dzięki nim możesz budować aplikacje React na najwyższym poziomie!

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

// =============================================
// CENTRUM DOWODZENIA MISJA KOSMICZNA
// Projekt laczacy: custom hooks, HOC, render props,
// compound components i najlepsze praktyki React
// =============================================

// --- Custom Hook: useMission ---
function useMission(initialName = '') {
  const [mission, setMission] = useState({
    name: initialName,
    status: 'planning',
    fuel: 100,
    crew: 0,
  });

  const launch = useCallback(() => {
    setMission(prev => {
      if (prev.fuel < 30) return prev;
      return { ...prev, status: 'in-progress' };
    });
  }, []);

  const complete = useCallback(() => {
    setMission(prev => ({ ...prev, status: 'completed' }));
  }, []);

  const abort = useCallback(() => {
    setMission(prev => ({ ...prev, status: 'aborted' }));
  }, []);

  const updateFuel = useCallback((amount) => {
    setMission(prev => ({
      ...prev,
      fuel: Math.max(0, Math.min(100, prev.fuel + amount)),
    }));
  }, []);

  const updateCrew = useCallback((count) => {
    setMission(prev => ({ ...prev, crew: Math.max(0, count) }));
  }, []);

  const rename = useCallback((name) => {
    setMission(prev => ({ ...prev, name }));
  }, []);

  return { mission, launch, complete, abort, updateFuel, updateCrew, rename };
}

// --- HOC: withStatusColor ---
function withStatusColor(WrappedComponent) {
  return function StatusColorComponent(props) {
    const colorMap = {
      planning: '#00d4ff',
      'in-progress': '#ffd700',
      completed: '#4CAF50',
      aborted: '#f44336',
    };
    const statusColor = colorMap[props.status] || '#e0e1dd';
    return <WrappedComponent {...props} statusColor={statusColor} />;
  };
}

// --- Compound Component: MissionPanel ---
function MissionPanel({ children }) {
  const [isExpanded, setIsExpanded] = useState(true);
  return (
    <div style={{
      background: '#1b2838', borderRadius: '12px',
      padding: '16px', marginBottom: '12px',
      border: '1px solid #2a3f5f',
    }}>
      {React.Children.map(children, child =>
        React.isValidElement(child)
          ? React.cloneElement(child, { isExpanded, setIsExpanded })
          : child
      )}
    </div>
  );
}

MissionPanel.Header = function Header({ isExpanded, setIsExpanded, children }) {
  return (
    <div
      onClick={() => setIsExpanded(!isExpanded)}
      style={{
        cursor: 'pointer', display: 'flex',
        justifyContent: 'space-between', alignItems: 'center',
        color: '#ffd700', fontSize: '16px', fontWeight: 'bold',
      }}
    >
      {children}
      <span>{isExpanded ? '▲' : '▼'}</span>
    </div>
  );
};

MissionPanel.Body = function Body({ isExpanded, children }) {
  if (!isExpanded) return null;
  return <div style={{ marginTop: '12px' }}>{children}</div>;
};

// --- Render Props: FuelGauge ---
function FuelGauge({ fuel, render }) {
  const level = fuel > 60 ? 'high' : fuel > 30 ? 'medium' : 'low';
  const color = level === 'high' ? '#4CAF50' : level === 'medium' ? '#ffd700' : '#f44336';
  return render({ fuel, level, color });
}

// --- Komponent z HOC ---
const StatusBadge = withStatusColor(memo(function StatusBadge({ status, statusColor }) {
  return (
    <span style={{
      display: 'inline-block', padding: '4px 12px',
      borderRadius: '12px', background: statusColor,
      color: '#0d1b2a', fontWeight: 'bold', fontSize: '13px',
    }}>
      {status.toUpperCase()}
    </span>
  );
}));

// --- Glowny komponent App ---
export default function App() {
  const { mission, launch, complete, abort, updateFuel, updateCrew, rename } = useMission('Apollo X');

  return (
    <div style={{
      background: '#0d1b2a', minHeight: '100vh',
      padding: '20px', fontFamily: 'Arial', color: '#e0e1dd',
    }}>
      <h1 style={{ color: '#ffd700', textAlign: 'center', marginBottom: '6px' }}>
        Centrum Dowodzenia
      </h1>
      <p style={{ textAlign: 'center', color: '#778da9', marginBottom: '20px', fontSize: '14px' }}>
        Projekt laczacy custom hooks, HOC, render props i compound components
      </p>

      {/* Panel misji - Compound Component */}
      <MissionPanel>
        <MissionPanel.Header>Dane Misji</MissionPanel.Header>
        <MissionPanel.Body>
          <div style={{ marginBottom: '10px' }}>
            <label style={{ color: '#778da9', fontSize: '13px' }}>Nazwa misji:</label>
            <input
              value={mission.name}
              onChange={e => rename(e.target.value)}
              style={{
                width: '100%', padding: '6px 10px', marginTop: '4px',
                background: '#0d1b2a', border: '1px solid #2a3f5f',
                borderRadius: '6px', color: '#e0e1dd', fontSize: '14px',
              }}
            />
          </div>
          <div style={{ display: 'flex', alignItems: 'center', gap: '10px', marginBottom: '10px' }}>
            <span style={{ color: '#778da9', fontSize: '13px' }}>Status:</span>
            <StatusBadge status={mission.status} />
          </div>
          <div style={{ display: 'flex', gap: '6px', flexWrap: 'wrap' }}>
            <button onClick={launch} style={btnStyle('#4CAF50')}>Start</button>
            <button onClick={complete} style={btnStyle('#2196F3')}>Zakoncz</button>
            <button onClick={abort} style={btnStyle('#f44336')}>Przerwij</button>
          </div>
        </MissionPanel.Body>
      </MissionPanel>

      {/* Paliwo - Render Props */}
      <MissionPanel>
        <MissionPanel.Header>Paliwo</MissionPanel.Header>
        <MissionPanel.Body>
          <FuelGauge fuel={mission.fuel} render={({ fuel, color }) => (
            <div>
              <div style={{
                width: '100%', height: '20px', background: '#0d1b2a',
                borderRadius: '10px', overflow: 'hidden', marginBottom: '8px',
              }}>
                <div style={{
                  width: fuel + '%', height: '100%',
                  background: color, borderRadius: '10px',
                  transition: 'all 0.3s',
                }} />
              </div>
              <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
                <span style={{ color, fontWeight: 'bold' }}>{fuel}%</span>
                <div style={{ display: 'flex', gap: '6px' }}>
                  <button onClick={() => updateFuel(-10)} style={btnStyle('#f44336')}>-10</button>
                  <button onClick={() => updateFuel(10)} style={btnStyle('#4CAF50')}>+10</button>
                </div>
              </div>
            </div>
          )} />
        </MissionPanel.Body>
      </MissionPanel>

      {/* Zaloga */}
      <MissionPanel>
        <MissionPanel.Header>Zaloga ({mission.crew} czlonkow)</MissionPanel.Header>
        <MissionPanel.Body>
          <div style={{ display: 'flex', gap: '6px' }}>
            <button onClick={() => updateCrew(mission.crew + 1)} style={btnStyle('#4CAF50')}>
              + Dodaj
            </button>
            <button onClick={() => updateCrew(mission.crew - 1)} style={btnStyle('#f44336')}>
              - Usun
            </button>
          </div>
        </MissionPanel.Body>
      </MissionPanel>
    </div>
  );
}

function btnStyle(bg) {
  return {
    padding: '6px 14px', background: bg, color: 'white',
    border: 'none', borderRadius: '6px', cursor: 'pointer',
    fontWeight: 'bold', fontSize: '13px',
  };
}

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

  1. Projekt do wysłaniaProjekt do mentora: Laboratorium wzorców Alpha Centauri
  2. WideoVideo: Podsumowanie modułu

Przydatne artykuły