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

Code splitting

10 min czytania ·
W tej lekcji14

W miarę jak nasza kosmiczna aplikacja React rośnie, plik JavaScript, który ładuje się w przeglądarce, również się powiększa. Może to prowadzić do dłuższych czasów ładowania strony, większego zużycia pamięci i ogólnie słabszej wydajności. Code splitting (podział kodu) to technika, która pozwala na "podział" aplikacji na mniejsze części, które mogą być ładowane dynamicznie, tylko wtedy, gdy są potrzebne.

Czym jest code splitting?

Code splitting to technika, która dzieli duży pakiet kodu JavaScript na mniejsze kawałki (tzw. "chunki"), które mogą być ładowane na żądanie lub równolegle. Zamiast wysyłać całą aplikację do użytkownika od razu, przesyłamy tylko to, co jest potrzebne do początkowego renderowania, a reszta jest ładowana w tle lub gdy jest potrzebna.

Jest to jak start kosmicznej misji - nie wysyłamy wszystkich zasobów od razu, ale etapami: najpierw statek główny, potem moduły dodatkowe, a na końcu mniejsze narzędzia i wyposażenie, gdy stają się potrzebne.

Dlaczego potrzebujemy code splitting?

Wyobraźmy sobie, że tworzymy kosmiczną aplikację z wieloma modułami:

  • Panel kontrolny misji
  • System monitorowania astronautów
  • Mapa galaktyki
  • Encyklopedia odkrytych planet
  • Symulator lotu
  • Centrum komunikacji międzygwiezdnej

Jeśli zbudujemy całą aplikację jako jeden pakiet, użytkownik musi pobrać cały ten kod, nawet jeśli chce tylko sprawdzić mapę galaktyki. W rezultacie:

  • Dłuższy czas ładowania pierwszej strony
  • Większe zużycie pamięci przeglądarki
  • Większe koszty transferu danych (szczególnie istotne na urządzeniach mobilnych)
  • Niepotrzebne ładowanie i parsowanie kodu, który nie jest używany

Korzyści z code splitting

  • Szybsze początkowe ładowanie - krótszy czas do interaktywności (TTI - Time To Interactive)
  • Lepsza wydajność na urządzeniach mobilnych - mniejsze zużycie pamięci i procesora
  • Priorytetyzacja krytycznych ścieżek - najważniejsze części aplikacji ładują się pierwsze
  • Lepsza pamięć podręczna - mniejsze części łatwiej się buforują i aktualizują
  • Lepsze doświadczenie użytkownika - aplikacja jest responsywna szybciej

Implementacja code splitting w React

React wspiera code splitting za pomocą dynamicznego importu i komponentu React.lazy. Zobaczmy, jak to działa:

1. Dynamiczny import

Funkcja import() to standardowa funkcja ES, która pozwala na dynamiczne importowanie modułów. Zamiast ładować wszystkie zależności na górze pliku, możemy załadować je tylko wtedy, gdy są potrzebne:

// Bez code splitting
import { calculateOrbit } from './complexOrbitCalculations';

function OrbitCalculator({ planetData }) {
  const orbitInfo = calculateOrbit(planetData);
  return <div>{/* Renderowanie wyników */}</div>;
}

// Z code splitting
function OrbitCalculator({ planetData }) {
  const [orbitInfo, setOrbitInfo] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => {
    // Dynamiczny import modułu dopiero, gdy komponent się zamontuje
    import('./complexOrbitCalculations')
      .then(module => {
        const result = module.calculateOrbit(planetData);
        setOrbitInfo(result);
        setLoading(false);
      });
  }, [planetData]);

  if (loading) return <p>Obliczanie orbity...</p>;
  return <div>{/* Renderowanie wyników */}</div>;
}

2. React.lazy

React.lazy to funkcja, która pozwala na renderowanie dynamicznego importu jako zwykłego komponentu. Działa tylko z domyślnymi eksportami (default exports).

import React, { Suspense } from 'react';

// Zwykły import
// import GalaxyMap from './GalaxyMap';

// Leniwy import
const GalaxyMap = React.lazy(() => import('./GalaxyMap'));
const PlanetDetails = React.lazy(() => import('./PlanetDetails'));
const SpaceshipControls = React.lazy(() => import('./SpaceshipControls'));

function SpaceExplorer() {
  const [view, setView] = useState('map');

  return (
    <div className="space-explorer">
      <nav>
        <button onClick={() => setView('map')}>Mapa Galaktyki</button>
        <button onClick={() => setView('planets')}>Szczegóły Planet</button>
        <button onClick={() => setView('controls')}>Panel Sterowania</button>
      </nav>

      <Suspense fallback={<div>Ładowanie modułu...</div>}>
        {view === 'map' && <GalaxyMap />}
        {view === 'planets' && <PlanetDetails />}
        {view === 'controls' && <SpaceshipControls />}
      </Suspense>
    </div>
  );
}

W powyższym przykładzie:

  1. Używamy React.lazy do dynamicznego importowania komponentów
  2. Opakowujemy komponenty w Suspense, aby pokazać fallback podczas ładowania
  3. Komponenty są ładowane tylko wtedy, gdy są potrzebne (gdy użytkownik zmienia widok)

Suspense

Suspense to komponent React, który pozwala na "zawieszenie" renderowania do momentu, aż pewne warunki zostają spełnione (np. dane są załadowane lub kod komponenty jest dostępny).

Suspense przyjmuje prop fallback, który jest renderowany podczas oczekiwania:

<Suspense fallback={<LoadingSpinner message="Przygotowywanie modułu..." />}>
  <LazilyLoadedComponent />
</Suspense>

Suspense może obsłużyć wiele komponentów Lazy na raz:

<Suspense fallback={<LoadingSpinner />}>
  <LazyComponent1 />
  <div>
    <LazyComponent2 />
  </div>
  <LazyComponent3 />
</Suspense>

Zagnieżdżanie Suspense

Możemy również zagnieżdżać komponenty Suspense, aby uzyskać bardziej granularną kontrolę nad tym, co jest wyświetlane podczas ładowania:

function SpaceStation() {
  return (
    <div>
      <h1>Stacja Kosmiczna Alpha</h1>

      {/* Główny układ ładuje się natychmiast */}
      <StationLayout />

      {/* Mapa ładuje się z własnym fallbackiem */}
      <Suspense fallback={<p>Wczytywanie mapy stacji...</p>}>
        <StationMap />
      </Suspense>

      {/* Panel kontrolny ma zagnieżdżone komponenty lazy */}
      <Suspense fallback={<p>Przygotowywanie panelu kontrolnego...</p>}>
        <ControlPanel>
          <Suspense fallback={<p>Ładowanie systemów podtrzymywania życia...</p>}>
            <LifeSupportMonitor />
          </Suspense>

          <Suspense fallback={<p>Ładowanie kontroli silników...</p>}>
            <EngineControls />
          </Suspense>
        </ControlPanel>
      </Suspense>
    </div>
  );
}

Code splitting w oparciu o routing

Jednym z najczęstszych sposobów zastosowania code splitting jest podział kodu na podstawie tras (routes). Każda strona lub widok staje się oddzielnym chunkiem kodu:

import React, { Suspense, lazy } from 'react';
import { BrowserRouter as Router, Route, Switch } from 'react-router-dom';
import Navbar from './Navbar';
import LoadingPage from './LoadingPage';

// Leniwe ładowanie stron
const MissionControl = lazy(() => import('./pages/MissionControl'));
const GalaxyMap = lazy(() => import('./pages/GalaxyMap'));
const CrewManagement = lazy(() => import('./pages/CrewManagement'));
const ResearchDatabase = lazy(() => import('./pages/ResearchDatabase'));
const SpaceshipConfig = lazy(() => import('./pages/SpaceshipConfig'));

function App() {
  return (
    <Router>
      <Navbar />
      <Suspense fallback={<LoadingPage />}>
        <Switch>
          <Route exact path="/" component={MissionControl} />
          <Route path="/galaxy-map" component={GalaxyMap} />
          <Route path="/crew" component={CrewManagement} />
          <Route path="/research" component={ResearchDatabase} />
          <Route path="/spaceship" component={SpaceshipConfig} />
        </Switch>
      </Suspense>
    </Router>
  );
}

Code splitting bibliotek

Możemy również stosować code splitting dla dużych bibliotek, które nie są potrzebne natychmiast:

import React, { useState } from 'react';

function DataVisualizer({ data }) {
  const [charts, setCharts] = useState(null);
  const [showCharts, setShowCharts] = useState(false);

  const loadChartsLibrary = async () => {
    // Załaduj bibliotekę dopiero, gdy użytkownik chce zobaczyć wykresy
    const D3Module = await import('d3');
    const ChartModule = await import('./ChartComponent');

    setCharts({
      d3: D3Module.default,
      ChartComponent: ChartModule.default
    });
  };

  const handleShowCharts = () => {
    if (!charts) {
      setShowCharts(true);
      loadChartsLibrary();
    } else {
      setShowCharts(true);
    }
  };

  return (
    <div className="data-visualizer">
      <h2>Dane eksploracji kosmicznej</h2>
      <button onClick={handleShowCharts}>
        {showCharts ? 'Ukryj wykresy' : 'Pokaż wykresy'}
      </button>

      {showCharts && (
        <>
          {charts ? (
            <charts.ChartComponent data={data} d3={charts.d3} />
          ) : (
            <p>Ładowanie zaawansowanych wykresów...</p>
          )}
        </>
      )}
    </div>
  );
}

Preloading

Czasami wiemy, że komponent będzie potrzebny wkrótce (np. gdy użytkownik najedzie na przycisk, który pokaże modal). Możemy zacząć ładować moduł wcześniej:

const PlanetExplorer = React.lazy(() => import('./PlanetExplorer'));

function PlanetInfoButton({ planetId }) {
  const [showExplorer, setShowExplorer] = useState(false);

  const handleMouseEnter = () => {
    // Rozpocznij pobieranie modułu, gdy użytkownik najedzie na przycisk
    const PlanetExplorerModule = import('./PlanetExplorer');
  };

  return (
    <>
      <button
        onMouseEnter={handleMouseEnter}
        onClick={() => setShowExplorer(true)}
      >
        Eksploruj planetę {planetId}
      </button>

      {showExplorer && (
        <Suspense fallback={<p>Przygotowywanie eksploratora...</p>}>
          <PlanetExplorer planetId={planetId} />
        </Suspense>
      )}
    </>
  );
}

Named exports i code splitting

React.lazy działa tylko z domyślnymi eksportami (default exports). Jeśli chcemy użyć nazwanych eksportów (named exports), musimy utworzyć pośredni moduł:

// MathUtils.js
export const calculateDistance = (a, b) => { /* ... */ };
export const calculateVelocity = (distance, time) => { /* ... */ };
export const calculateAcceleration = (velocity, time) => { /* ... */ };

// DistanceCalculator.js (moduł pośredni)
export { calculateDistance } from './MathUtils';
export default calculateDistance;

// Użycie
const DistanceCalculator = React.lazy(() => import('./DistanceCalculator'));

Alternatywnie, możemy ręcznie obsłużyć import i wyodrębnić żądany eksport:

const calculateVelocity = React.lazy(() =>
  import('./MathUtils').then(module => ({ default: module.calculateVelocity }))
);

Strategie dzielenia kodu

1. Podział według tras (Routes)

Najczęstszy i najłatwiejszy sposób - każda strona to oddzielny chunk kodu.

2. Podział według funkcjonalności (Feature-based)

Komponenty związane z określoną funkcjonalnością (np. panel administracyjny, zaawansowana analityka) są grupowane razem.

// Ładowanie całego modułu administratora na żądanie
const AdminDashboard = React.lazy(() => import('./admin/Dashboard'));

function App() {
  const [isAdmin, setIsAdmin] = useState(false);

  // isAdmin jest ustawiane po logowaniu użytkownika

  return (
    <div>
      {isAdmin ? (
        <Suspense fallback={<p>Ładowanie panelu admina...</p>}>
          <AdminDashboard />
        </Suspense>
      ) : (
        <UserDashboard />
      )}
    </div>
  );
}

3. Podział według priorytetu (Priority-based)

Krytyczne komponenty ładowane od razu, mniej ważne leniwie.

// Krytyczne komponenty importowane standardowo
import CriticalSystemStatus from './CriticalSystemStatus';
import NavigationControls from './NavigationControls';

// Mniej istotne komponenty ładowane leniwie
const SystemLogs = React.lazy(() => import('./SystemLogs'));
const CrewSchedule = React.lazy(() => import('./CrewSchedule'));
const MaintenanceStatus = React.lazy(() => import('./MaintenanceStatus'));

function SpaceshipDashboard() {
  return (
    <div className="dashboard">
      <div className="critical-section">
        <CriticalSystemStatus />
        <NavigationControls />
      </div>

      <Suspense fallback={<p>Ładowanie dodatkowych modułów...</p>}>
        <div className="secondary-section">
          <SystemLogs />
          <CrewSchedule />
          <MaintenanceStatus />
        </div>
      </Suspense>
    </div>
  );
}

4. Podział przy użyciu bibliotek (Vendor splitting)

Dzielenie dużych bibliotek zewnętrznych na oddzielne chunki.

W webpack można to osiągnąć za pomocą konfiguracji splitChunks:

module.exports = {
  //...
  optimization: {
    splitChunks: {
      chunks: 'all',
      maxInitialRequests: Infinity,
      minSize: 0,
      cacheGroups: {
        vendor: {
          test: /[\/]node_modules[\/]/,
          name(module) {
            // get the name. E.g. node_modules/packageName/sub/path
            // or node_modules/packageName
            const packageName = module.context.match(
              /[\/]node_modules[\/](.*?)([\/]|$)/
            )[1];

            // npm package names are URL-safe, but some servers don't like @ symbols
            return `npm.${packageName.replace('@', '')}`;
          },
        },
      },
    },
  },
};

Analiza i debugowanie code splitting

Analizowanie wielkości paczek

Narzędzia takie jak "webpack-bundle-analyzer" lub "source-map-explorer" pomagają wizualizować zawartość paczek i identyfikować możliwości podziału:

# Instalacja
npm install --save-dev webpack-bundle-analyzer

# Konfiguracja w webpack.config.js
const BundleAnalyzerPlugin = require('webpack-bundle-analyzer').BundleAnalyzerPlugin;

module.exports = {
  plugins: [
    new BundleAnalyzerPlugin()
  ]
}

Debugowanie problemów z code-splitting

Częste problemy z code splitting i ich rozwiązania:

  1. Komponenty migają podczas ładowania

    • Rozwiązanie: Zaprojektuj fallback tak, aby pasował do układu końcowego komponentu
  2. Za dużo małych chunków

    • Rozwiązanie: Grupuj powiązane komponenty w jednym dynamic import
  3. Problemy z SSR (Server-Side Rendering)

    • Rozwiązanie: Użyj loadable-components zamiast React.lazy dla SSR

Dobre praktyki w zakresie code splitting

  1. Nie przesadzaj z podziałem - zbyt wiele małych chunków może prowadzić do problemów z wydajnością ze względu na liczne żądania HTTP

  2. Analizuj swoje paczki - regularnie monitoruj rozmiar i zawartość bundli

  3. Używaj Magic Comments w webpack do lepszej kontroli nad chunkami:

    // Nazwany chunk
    const HomeComponent = React.lazy(() => import(
      /* webpackChunkName: "home" */
      './HomeComponent'
    ));
    
    // Prefetch - zasugeruj przeglądarce, że ten zasób będzie potrzebny
    const SettingsComponent = React.lazy(() => import(
      /* webpackChunkName: "settings" */
      /* webpackPrefetch: true */
      './SettingsComponent'
    ));
    
    // Preload - załaduj ten zasób z wysokim priorytetem
    const ProfileComponent = React.lazy(() => import(
      /* webpackChunkName: "profile" */
      /* webpackPreload: true */
      './ProfileComponent'
    ));
  4. Używaj code splitting w połączeniu z pamięcią podręczną - prawidłowo skonfigurowane nagłówki cache dla chunków mogą znacznie poprawić wydajność

  5. Monitoruj wpływ na wydajność - używaj narzędzi takich jak Lighthouse, aby mierzyć czasy ładowania i TTI (Time To Interactive)

Code splitting a TypeScript

TypeScript działa dobrze z code splitting, ale wymaga kilku dodatkowych kroków:

// Upewnij się, że w tsconfig.json jest ustawione:
// "module": "esnext"

// Dynamiczny import z typowaniem
const DataVisualization = React.lazy(() =>
  import('./DataVisualization') as Promise<{ default: React.ComponentType<DataVisProps> }>
);

interface DataVisProps {
  data: Array<DataPoint>;
  width: number;
  height: number;
}

interface DataPoint {
  x: number;
  y: number;
  label: string;
}

function Dashboard() {
  const [data, setData] = useState<Array<DataPoint>>([]);

  return (
    <div>
      <h1>Panel misji kosmicznej</h1>

      <Suspense fallback={<div>Ładowanie wizualizacji...</div>}>
        <DataVisualization
          data={data}
          width={800}
          height={400}
        />
      </Suspense>
    </div>
  );
}

Podsumowanie

Code splitting to potężna technika optymalizacji, która pozwala na znaczne polepszenie wydajności aplikacji React, szczególnie dla większych projektów. Dzięki podziałowi kodu użytkownicy ładują tylko to, czego potrzebują, co prowadzi do szybszego uruchomienia aplikacji i lepszego doświadczenia użytkownika.

Kluczowe narzędzia i metody to:

  • React.lazy() i Suspense dla komponentów
  • Dynamiczny import() dla modułów
  • Strategie podziału oparte na trasach, funkcjonalności lub priorytecie
  • Narzędzia analizy bundli pomagające w podejmowaniu decyzji

Wdrażając code splitting w naszej kosmicznej aplikacji, możemy zapewnić, że użytkownicy szybko uzyskają dostęp do najważniejszych funkcji, a dodatkowe zasoby będą ładowane wtedy, gdy będą potrzebne - podobnie jak w wieloetapowej misji kosmicznej, gdzie każdy moduł jest dostarczany we właściwym czasie.

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

// ============================================
// PATTERN: Compound Components
// ============================================
// Komponenty współdzielące stan przez Context

// Context dla Accordion
const AccordionContext = createContext();

function useAccordion() {
  const context = useContext(AccordionContext);
  if (!context) {
    throw new Error('Accordion components must be used within <Accordion>');
  }
  return context;
}

// Główny komponent Accordion
function Accordion({ children, defaultOpen = null }) {
  const [openItem, setOpenItem] = useState(defaultOpen);

  const toggle = (id) => {
    setOpenItem(prev => prev === id ? null : id);
  };

  return (
    <AccordionContext.Provider value={{ openItem, toggle }}>
      <div style={styles.accordion}>
        {children}
      </div>
    </AccordionContext.Provider>
  );
}

// Sub-komponent: Item
function AccordionItem({ children, id }) {
  const { openItem } = useAccordion();
  const isOpen = openItem === id;

  return (
    <div style={{
      ...styles.item,
      borderColor: isOpen ? '#00d4ff' : 'rgba(255,255,255,0.1)',
    }}>
      {React.Children.map(children, child =>
        React.cloneElement(child, { itemId: id, isOpen })
      )}
    </div>
  );
}

// Sub-komponent: Header
function AccordionHeader({ children, itemId }) {
  const { openItem, toggle } = useAccordion();
  const isOpen = openItem === itemId;

  return (
    <button
      onClick={() => toggle(itemId)}
      style={styles.header}
    >
      <span>{children}</span>
      <span style={{
        transform: isOpen ? 'rotate(180deg)' : 'rotate(0)',
        transition: 'transform 0.3s ease',
      }}>
        ▼
      </span>
    </button>
  );
}

// Sub-komponent: Panel
function AccordionPanel({ children, isOpen }) {
  return (
    <div style={{
      ...styles.panel,
      maxHeight: isOpen ? '500px' : '0',
      padding: isOpen ? '20px' : '0 20px',
      opacity: isOpen ? 1 : 0,
    }}>
      {children}
    </div>
  );
}

// Łączymy komponenty
Accordion.Item = AccordionItem;
Accordion.Header = AccordionHeader;
Accordion.Panel = AccordionPanel;

// ============================================
// PATTERN: Tabs Compound Component
// ============================================

const TabsContext = createContext();

function Tabs({ children, defaultTab }) {
  const [activeTab, setActiveTab] = useState(defaultTab);

  return (
    <TabsContext.Provider value={{ activeTab, setActiveTab }}>
      <div style={styles.tabs}>
        {children}
      </div>
    </TabsContext.Provider>
  );
}

function TabList({ children }) {
  return (
    <div style={styles.tabList}>
      {children}
    </div>
  );
}

function Tab({ children, id }) {
  const { activeTab, setActiveTab } = useContext(TabsContext);
  const isActive = activeTab === id;

  return (
    <button
      onClick={() => setActiveTab(id)}
      style={{
        ...styles.tab,
        background: isActive ? '#00d4ff' : 'transparent',
        color: isActive ? '#000' : '#fff',
      }}
    >
      {children}
    </button>
  );
}

function TabPanels({ children }) {
  return <div>{children}</div>;
}

function TabPanel({ children, id }) {
  const { activeTab } = useContext(TabsContext);

  if (activeTab !== id) return null;

  return (
    <div style={styles.tabPanel}>
      {children}
    </div>
  );
}

Tabs.List = TabList;
Tabs.Tab = Tab;
Tabs.Panels = TabPanels;
Tabs.Panel = TabPanel;

// ============================================
// Demo App
// ============================================

function CompoundComponentsDemo() {
  return (
    <div style={styles.container}>
      <header style={styles.headerSection}>
        <h1 style={styles.title}>Compound Components</h1>
        <p style={styles.subtitle}>
          Wzorzec projektowy dla komponentów współdzielących stan
        </p>
      </header>

      <div style={styles.content}>
        {/* Accordion Demo */}
        <div style={styles.section}>
          <h2 style={styles.sectionTitle}>Accordion</h2>

          <Accordion defaultOpen="item1">
            <Accordion.Item id="item1">
              <Accordion.Header>Czym są Compound Components?</Accordion.Header>
              <Accordion.Panel>
                <p>
                  Compound Components to wzorzec, w którym komponenty współdzielą
                  stan wewnętrzny poprzez Context. Pozwala to na tworzenie
                  elastycznych i czytelnych API komponentów.
                </p>
              </Accordion.Panel>
            </Accordion.Item>

            <Accordion.Item id="item2">
              <Accordion.Header>Zalety wzorca</Accordion.Header>
              <Accordion.Panel>
                <ul style={{ marginLeft: '20px' }}>
                  <li>Czytelna i deklaratywna składnia</li>
                  <li>Elastyczność w układzie komponentów</li>
                  <li>Enkapsulacja logiki w rodzicu</li>
                  <li>Łatwe dodawanie nowych funkcjonalności</li>
                </ul>
              </Accordion.Panel>
            </Accordion.Item>

            <Accordion.Item id="item3">
              <Accordion.Header>Implementacja</Accordion.Header>
              <Accordion.Panel>
                <p>
                  Implementacja opiera się na React Context do współdzielenia
                  stanu oraz na static properties dla grupowania sub-komponentów.
                </p>
              </Accordion.Panel>
            </Accordion.Item>
          </Accordion>
        </div>

        {/* Tabs Demo */}
        <div style={styles.section}>
          <h2 style={styles.sectionTitle}>Tabs</h2>

          <Tabs defaultTab="tab1">
            <Tabs.List>
              <Tabs.Tab id="tab1">Planety</Tabs.Tab>
              <Tabs.Tab id="tab2">Gwiazdy</Tabs.Tab>
              <Tabs.Tab id="tab3">Galaktyki</Tabs.Tab>
            </Tabs.List>

            <Tabs.Panels>
              <Tabs.Panel id="tab1">
                <h3>Planety Układu Słonecznego</h3>
                <p>Merkury, Wenus, Ziemia, Mars, Jowisz, Saturn, Uran, Neptun</p>
              </Tabs.Panel>
              <Tabs.Panel id="tab2">
                <h3>Typy gwiazd</h3>
                <p>Gwiazdy dzielą się na karły, olbrzymy, nadolbrzymy i inne typy spektralne.</p>
              </Tabs.Panel>
              <Tabs.Panel id="tab3">
                <h3>Rodzaje galaktyk</h3>
                <p>Galaktyki spiralne, eliptyczne, nieregularne i soczewkowate.</p>
              </Tabs.Panel>
            </Tabs.Panels>
          </Tabs>
        </div>
      </div>

      <footer style={styles.footer}>
        <p>Compound Components • Context API • Static Properties</p>
      </footer>
    </div>
  );
}

const styles = {
  container: {
    minHeight: '100vh',
    background: 'linear-gradient(135deg, #1a1a2e 0%, #16213e 100%)',
    padding: '30px',
    fontFamily: "'Segoe UI', sans-serif",
    color: '#fff',
  },
  headerSection: {
    textAlign: 'center',
    marginBottom: '40px',
  },
  title: {
    fontSize: '2.5em',
    color: '#00d4ff',
    marginBottom: '10px',
  },
  subtitle: {
    opacity: 0.7,
  },
  content: {
    maxWidth: '800px',
    margin: '0 auto',
  },
  section: {
    background: 'rgba(255,255,255,0.05)',
    borderRadius: '15px',
    padding: '25px',
    marginBottom: '25px',
    border: '1px solid rgba(255,255,255,0.1)',
  },
  sectionTitle: {
    color: '#ffd700',
    marginBottom: '20px',
  },
  accordion: {
    display: 'flex',
    flexDirection: 'column',
    gap: '10px',
  },
  item: {
    borderRadius: '10px',
    border: '2px solid',
    overflow: 'hidden',
    transition: 'border-color 0.3s ease',
  },
  header: {
    width: '100%',
    padding: '15px 20px',
    background: 'rgba(255,255,255,0.05)',
    border: 'none',
    color: '#fff',
    fontSize: '16px',
    cursor: 'pointer',
    display: 'flex',
    justifyContent: 'space-between',
    alignItems: 'center',
  },
  panel: {
    overflow: 'hidden',
    transition: 'all 0.3s ease',
    lineHeight: 1.6,
  },
  tabs: {},
  tabList: {
    display: 'flex',
    gap: '10px',
    marginBottom: '20px',
  },
  tab: {
    padding: '12px 24px',
    border: '2px solid #00d4ff',
    borderRadius: '8px',
    cursor: 'pointer',
    fontWeight: 'bold',
    transition: 'all 0.3s ease',
  },
  tabPanel: {
    padding: '20px',
    background: 'rgba(255,255,255,0.05)',
    borderRadius: '10px',
  },
  footer: {
    textAlign: 'center',
    marginTop: '40px',
    opacity: 0.7,
  },
};

export default CompoundComponentsDemo;

Hasła z dokumentacji w tej lekcji

Widzisz błąd w tej lekcji?

Zadania praktyczne w grze

  • Klikanie w kolejności

    Ułóż składnię React.lazy z dynamicznym importem:

  1. Kliknij w kolejnościReact.lazy i Suspense

Przydatne artykuły