Kurs JavaScript i React · Moduł 8: Zaawansowane wzorce React
Code splitting
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:
- Używamy
React.lazydo dynamicznego importowania komponentów - Opakowujemy komponenty w
Suspense, aby pokazać fallback podczas ładowania - 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:
Komponenty migają podczas ładowania
- Rozwiązanie: Zaprojektuj fallback tak, aby pasował do układu końcowego komponentu
Za dużo małych chunków
- Rozwiązanie: Grupuj powiązane komponenty w jednym dynamic import
Problemy z SSR (Server-Side Rendering)
- Rozwiązanie: Użyj
loadable-componentszamiastReact.lazydla SSR
- Rozwiązanie: Użyj
Dobre praktyki w zakresie code splitting
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
Analizuj swoje paczki - regularnie monitoruj rozmiar i zawartość bundli
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' ));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ść
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()iSuspensedla 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: