Kurs JavaScript i React · Moduł 1: Podstawy React
Struktura projektu React
W tej lekcji8
Dobrze zorganizowana struktura projektu jest kluczowa dla utrzymania kodu, łatwej nawigacji i skalowalności aplikacji React. W tej lekcji przyjrzymy się najlepszym praktykom strukturyzowania projektów React i zrozumiemy, jak organizować pliki i komponenty.
Podstawowa struktura projektu React
Niezależnie od narzędzia, rozbudowany projekt React (tu na przykładzie Vite) ma zwykle podobną strukturę:
moj-projekt-react/
├── node_modules/ # Zainstalowane zależności
├── public/ # Pliki statyczne dostępne publicznie
├── src/ # Kod źródłowy aplikacji
│ ├── components/ # Komponenty wielokrotnego użytku
│ ├── pages/ # Komponenty reprezentujące całe strony
│ ├── assets/ # Zasoby takie jak obrazy, fonty itp.
│ ├── utils/ # Funkcje pomocnicze
│ ├── services/ # Kod odpowiedzialny za komunikację API
│ ├── hooks/ # Niestandardowe hooki React
│ ├── context/ # Konteksty React
│ ├── App.jsx # Główny komponent aplikacji
│ └── main.jsx # Punkt wejściowy aplikacji
├── index.html # Strona HTML, do której trafia aplikacja
├── vite.config.js # Konfiguracja Vite
├── .gitignore # Pliki ignorowane przez Git
├── package.json # Informacje o projekcie i zależności
└── README.md # Dokumentacja projektuOmówmy najważniejsze katalogi i ich przeznaczenie:
Katalog src/
Katalog src/ to serce Twojej aplikacji React. Zawiera całą logikę, komponenty i zasoby. Oto jak zazwyczaj organizuje się ten katalog:
components/
Zawiera komponenty wielokrotnego użytku, które są używane w różnych częściach aplikacji. Istnieje kilka podejść do strukturyzowania komponentów:
Struktura płaska
components/
├── Button.jsx
├── Button.css
├── Header.jsx
├── Header.css
├── Footer.jsx
└── Footer.cssStruktura pogrupowana (preferowana dla większych projektów)
components/
├── Button/
│ ├── Button.jsx
│ ├── Button.css
│ └── index.js
├── Header/
│ ├── Header.jsx
│ ├── Header.css
│ └── index.js
└── Footer/
├── Footer.jsx
├── Footer.css
└── index.jsUżywanie plików index.js do eksportowania komponentów upraszcza importy:
// Zamiast:
import Button from './components/Button/Button';
// Możesz pisać:
import Button from './components/Button';pages/
Komponenty reprezentujące całe strony lub widoki w aplikacji. W projektach z routingiem, każdy plik w tym katalogu zazwyczaj odpowiada określonej ścieżce URL:
pages/
├── Home/
│ ├── Home.jsx
│ └── Home.css
├── About/
│ ├── About.jsx
│ └── About.css
└── Dashboard/
├── Dashboard.jsx
└── Dashboard.cssassets/
Zawiera wszystkie statyczne zasoby używane w aplikacji:
assets/
├── images/
│ ├── logo.png
│ └── background.jpg
├── fonts/
│ ├── roboto.ttf
│ └── open-sans.ttf
└── styles/
├── variables.css
└── global.cssutils/
Funkcje pomocnicze i narzędzia używane w całej aplikacji:
utils/
├── formatDate.js
├── validation.js
└── helpers.jsservices/
Kod odpowiedzialny za komunikację z zewnętrznymi API lub usługami:
services/
├── api.js # Podstawowa konfiguracja API
├── userService.js # Zapytania związane z użytkownikami
└── productService.js # Zapytania związane z produktamihooks/
Niestandardowe hooki React, które można używać w wielu miejscach aplikacji:
hooks/
├── useLocalStorage.js
├── useFetch.js
└── useForm.jscontext/
Konteksty React używane do zarządzania globalnym stanem:
context/
├── AuthContext.js
├── ThemeContext.js
└── CartContext.jsOrganizacja według funkcji vs. według typu
Istnieją dwa główne podejścia do organizacji kodu:
Organizacja według typu (pokazana powyżej)
Pliki są grupowane według ich typu (komponenty, hooki, usługi itp.).
Organizacja według funkcji
Pliki są grupowane według funkcji lub części aplikacji:
src/
├── auth/
│ ├── components/
│ ├── hooks/
│ ├── services/
│ └── context/
├── products/
│ ├── components/
│ ├── hooks/
│ ├── services/
│ └── utils/
└── checkout/
├── components/
├── hooks/
└── services/Ta struktura jest bardziej skalowalna dla dużych projektów, szczególnie gdy pracuje nad nimi wiele osób.
Konwencje nazewnictwa
Spójne nazewnictwo jest równie ważne jak struktura katalogów:
Komponenty
- Używaj PascalCase:
Button.jsx,UserProfile.jsx - Pliki JSX powinny mieć rozszerzenie
.jsx(nie jest to konieczne, ale pomaga w identyfikacji)
Hooki
- Zawsze zaczynaj od "use":
useLocalStorage.js,useWindowSize.js
Konteksty
- Zazwyczaj kończą się na "Context":
AuthContext.js,ThemeContext.js
Usługi i narzędzia
- Używaj camelCase:
apiService.js,formatDate.js
Style w React
Istnieje kilka podejść do organizacji stylów w React:
CSS Modules
Button/
├── Button.jsx
└── Button.module.cssStyled Components
Button/
└── Button.jsx # Zawiera definicje styled-componentsSCSS/SASS
Button/
├── Button.jsx
└── Button.scssDobre praktyki struktury folderów
W kosmicznej flocie React, dobrze zorganizowana struktura folderów to jak efektywny system logistyczny na statku kosmicznym - wszystko ma swoje miejsce i można szybko znaleźć to, czego potrzebujemy. Oto sprawdzone praktyki organizacji projektów React.
Organizacja według funkcji a według typu
Dwa główne podejścia do organizacji kodu w projektach React:
Organizacja według typu (type-based)
Pliki grupowane według ich roli technicznej - wszystkie komponenty razem, wszystkie hooki razem, etc.
src/
├── components/
│ ├── Button/
│ ├── Card/
│ ├── Modal/
│ ├── UserProfile/
│ ├── ProductCard/
│ └── ShoppingCart/
├── hooks/
│ ├── useAuth.js
│ ├── useProducts.js
│ └── useCart.js
├── services/
│ ├── authService.js
│ ├── productService.js
│ └── cartService.js
└── utils/
├── validators.js
└── formatters.jsZalety:
- Prostsza dla małych i średnich projektów
- Łatwa do zrozumienia dla nowych programistów
- Dobra dla aplikacji SPA bez wyraźnych modułów
Wady:
- W dużych projektach trudno znaleźć wszystkie pliki związane z jedną funkcjonalnością
- Komponenty z różnych funkcjonalności są wymieszane
- Trudniejsze do skalowania w zespołach
Organizacja według funkcji (feature-based)
Pliki grupowane według funkcjonalności biznesowej - wszystkie pliki dotyczące autentykacji razem, wszystkie dotyczące produktów razem, etc.
src/
├── features/
│ ├── auth/
│ │ ├── components/
│ │ │ ├── LoginForm/
│ │ │ ├── RegisterForm/
│ │ │ └── PasswordReset/
│ │ ├── hooks/
│ │ │ ├── useAuth.js
│ │ │ └── useSession.js
│ │ ├── services/
│ │ │ └── authService.js
│ │ ├── utils/
│ │ │ └── validators.js
│ │ └── index.js
│ │
│ ├── products/
│ │ ├── components/
│ │ │ ├── ProductList/
│ │ │ ├── ProductCard/
│ │ │ └── ProductDetails/
│ │ ├── hooks/
│ │ │ ├── useProducts.js
│ │ │ └── useProductFilters.js
│ │ ├── services/
│ │ │ └── productService.js
│ │ └── index.js
│ │
│ └── cart/
│ ├── components/
│ │ ├── ShoppingCart/
│ │ ├── CartItem/
│ │ └── Checkout/
│ ├── hooks/
│ │ └── useCart.js
│ ├── services/
│ │ └── cartService.js
│ └── index.js
│
├── shared/
│ ├── components/
│ │ ├── Button/
│ │ ├── Modal/
│ │ └── Card/
│ ├── hooks/
│ │ ├── useLocalStorage.js
│ │ └── useDebounce.js
│ └── utils/
│ ├── formatDate.js
│ └── formatCurrency.js
│
└── App.jsxZalety:
- Łatwiejsze skalowanie dla dużych projektów
- Wszystkie pliki związane z funkcją są w jednym miejscu
- Łatwiejsze do pracy w zespołach (różne zespoły mogą pracować nad różnymi funkcjami)
- Łatwiejsze do usuwania całych funkcjonalności
- Lepsze dla code splitting
Wady:
- Bardziej skomplikowana dla początkujących
- Wymaga więcej przemyślenia przy projektowaniu
- Może prowadzić do duplikacji dla bardzo małych komponentów
Konwencje nazewnictwa
Spójne nazewnictwo to kluczowy element dobrze zorganizowanego projektu. W React obowiązują następujące konwencje:
Komponenty - PascalCase
// DOBRZE - PascalCase
Button.jsx
UserProfile.jsx
ShoppingCart.jsx
ProductCard.jsx
// ŹLE - inne konwencje
button.jsx
user-profile.jsx
shopping_cart.jsxDlaczego PascalCase?
- Odróżnia komponenty React od zwykłych funkcji
- Konwencja przyjęta w całym ekosystemie React
- JSX wymaga PascalCase dla komponentów (niestandardowe tagi)
Hooki - camelCase z przedrostkiem "use"
// DOBRZE - camelCase z "use"
useAuth.js
useLocalStorage.js
useWindowSize.js
useProductFilters.js
// ŹLE - brak "use" lub zła konwencja
Auth.js
local-storage.js
WindowSize.jsDlaczego "use" prefix?
- React wymaga aby niestandardowe hooki zaczynały się od "use"
- Pozwala React na walidację reguł hooków
- Natychmiast komunikuje, że to hook
Konteksty - PascalCase z sufiksem "Context"
// DOBRZE - PascalCase z "Context"
AuthContext.js
ThemeContext.js
CartContext.js
UserPreferencesContext.js
// ŹLE - brak "Context" lub zła konwencja
auth.js
theme-context.js
Cart.jsUtils i services - camelCase
// DOBRZE - camelCase
formatDate.js
validateEmail.js
apiService.js
authService.js
// ŹLE - inne konwencje
FormatDate.js
validate-email.js
API_Service.jsGdzie trzymać różne typy plików
Rozplanowanie lokalizacji plików w projekcie ma ogromne znaczenie dla jego czytelności i skalowalności.
Hooks (niestandardowe hooki)
Feature-based approach:
features/
├── auth/
│ └── hooks/
│ ├── useAuth.js
│ └── useSession.js
└── products/
└── hooks/
└── useProducts.js
shared/
└── hooks/
├── useLocalStorage.js # Współdzielony hook
├── useDebounce.js # Współdzielony hook
└── useFetch.js # Współdzielony hookType-based approach:
hooks/
├── useAuth.js
├── useSession.js
├── useProducts.js
├── useLocalStorage.js
├── useDebounce.js
└── useFetch.jsUtils (funkcje pomocnicze)
Feature-based approach:
features/
├── products/
│ └── utils/
│ ├── formatPrice.js
│ └── filterProducts.js
└── auth/
└── utils/
└── validatePassword.js
shared/
└── utils/
├── formatDate.js # Współdzielone
├── debounce.js # Współdzielone
└── cloneDeep.js # WspółdzieloneType-based approach:
utils/
├── formatPrice.js
├── formatDate.js
├── validatePassword.js
├── filterProducts.js
├── debounce.js
└── cloneDeep.jsTypes (TypeScript)
Jeśli używasz TypeScript, masz kilka opcji dla typów:
Opcja 1: Obok plików, które używają:
components/
└── Button/
├── Button.tsx
├── Button.types.ts # Typy tylko dla Button
├── Button.styles.ts
└── index.tsOpcja 2: Scentralizowane typy:
types/
├── user.types.ts
├── product.types.ts
├── cart.types.ts
└── api.types.tsOpcja 3: Hybrydowe (najlepsze):
features/
└── products/
├── components/
├── types/ # Typy specyficzne dla feature
│ ├── product.types.ts
│ └── filter.types.ts
└── index.ts
shared/
└── types/ # Typy współdzielone
├── common.types.ts
└── api.types.tsPrzykładowa struktura projektu - najlepsze praktyki
Połączenie feature-based dla głównych funkcjonalności i type-based dla współdzielonych zasobów:
moja-aplikacja-react/
├── public/
├── src/
│ ├── features/ # Główne funkcjonalności
│ │ ├── auth/
│ │ │ ├── components/
│ │ │ │ ├── LoginForm/
│ │ │ │ │ ├── LoginForm.tsx
│ │ │ │ │ ├── LoginForm.styles.ts
│ │ │ │ │ ├── LoginForm.test.tsx
│ │ │ │ │ └── index.ts
│ │ │ │ └── RegisterForm/
│ │ │ ├── hooks/
│ │ │ │ ├── useAuth.ts
│ │ │ │ └── useSession.ts
│ │ │ ├── services/
│ │ │ │ └── authService.ts
│ │ │ ├── types/
│ │ │ │ └── auth.types.ts
│ │ │ └── index.ts
│ │ │
│ │ ├── products/
│ │ │ ├── components/
│ │ │ │ ├── ProductList/
│ │ │ │ ├── ProductCard/
│ │ │ │ └── ProductFilters/
│ │ │ ├── hooks/
│ │ │ │ ├── useProducts.ts
│ │ │ │ └── useProductFilters.ts
│ │ │ ├── services/
│ │ │ │ └── productService.ts
│ │ │ ├── types/
│ │ │ │ └── product.types.ts
│ │ │ └── index.ts
│ │ │
│ │ └── cart/
│ │ └── [podobna struktura]
│ │
│ ├── shared/ # Współdzielone zasoby
│ │ ├── components/
│ │ │ ├── Button/
│ │ │ │ ├── Button.tsx
│ │ │ │ ├── Button.styles.ts
│ │ │ │ ├── Button.test.tsx
│ │ │ │ └── index.ts
│ │ │ ├── Modal/
│ │ │ ├── Card/
│ │ │ └── Layout/
│ │ │
│ │ ├── hooks/
│ │ │ ├── useLocalStorage.ts
│ │ │ ├── useDebounce.ts
│ │ │ └── useFetch.ts
│ │ │
│ │ ├── utils/
│ │ │ ├── formatDate.ts
│ │ │ ├── validators.ts
│ │ │ └── helpers.ts
│ │ │
│ │ ├── types/
│ │ │ ├── common.types.ts
│ │ │ └── api.types.ts
│ │ │
│ │ └── constants/
│ │ ├── routes.ts
│ │ └── config.ts
│ │
│ ├── layouts/ # Layout komponenty
│ │ ├── MainLayout/
│ │ ├── AuthLayout/
│ │ └── DashboardLayout/
│ │
│ ├── pages/ # Komponenty stron (dla routingu)
│ │ ├── HomePage/
│ │ ├── ProductsPage/
│ │ ├── ProductDetailPage/
│ │ └── CartPage/
│ │
│ ├── context/ # Globalne konteksty
│ │ ├── AuthContext.tsx
│ │ ├── ThemeContext.tsx
│ │ └── CartContext.tsx
│ │
│ ├── router/ # Konfiguracja routingu
│ │ ├── routes.tsx
│ │ └── ProtectedRoute.tsx
│ │
│ ├── styles/ # Globalne style
│ │ ├── globals.css
│ │ ├── variables.css
│ │ └── reset.css
│ │
│ ├── App.tsx
│ └── index.tsx
│
├── .eslintrc.js
├── .prettierrc
├── tsconfig.json
├── package.json
└── README.mdZasady organizacji plików
- Reguła 3 poziomów maksymalnie
- Unikaj głębszego zagnieżdżenia niż 3 poziomy
- Jeśli potrzebujesz więcej, prawdopodobnie twoja struktura jest za skomplikowana
// DOBRZE - 3 poziomy
src/features/products/components/
// ŹLE - za głębokie
src/modules/ecommerce/features/products/ui/components/- Eksportuj przez index.ts
- Każdy folder z komponentem ma index.ts
- Upraszcza importy i ukrywa szczegóły implementacji
// components/Button/index.ts
export { default } from './Button';
export * from './Button.types';
// Użycie
import Button from './components/Button'; // czytelne
// zamiast
import Button from './components/Button/Button'; // rozwlekłe- Colocation - trzymaj blisko to, co jest używane razem
- Style obok komponentu
- Testy obok komponentu
- Typy obok komponentu
Button/
├── Button.tsx # Komponent
├── Button.styles.ts # Style
├── Button.test.tsx # Testy
├── Button.types.ts # Typy
└── index.ts # Eksport- Shared vs Feature-specific
- Jeśli coś jest używane w więcej niż 2 miejscach → shared
- Jeśli coś jest specyficzne dla feature → trzymaj w feature
Praktyczne wskazówki dotyczące struktury projektu
Zacznij prosto - Nie przesadzaj ze skomplikowaną strukturą na początku projektu. Dla małej aplikacji type-based może wystarczyć, dopiero później refaktoryzuj do feature-based gdy projekt urośnie.
Refaktoryzuj, gdy zajdzie potrzeba - Dostosowuj strukturę w miarę rozwoju projektu. Jeśli folder ma więcej niż 10-15 plików, rozważ jego podział.
Utrzymuj małe komponenty - Komponenty powinny być małe i skupione na jednym zadaniu. Jeśli komponent ma więcej niż 200-300 linii, rozważ jego podział.
Grupuj powiązane pliki - Trzymaj razem pliki, które są ze sobą ściśle powiązane. Jeśli zawsze edytujesz dwa pliki razem, prawdopodobnie powinny być w tym samym folderze.
Dokumentuj - Dodaj README.md do głównych katalogów, aby wyjaśnić ich przeznaczenie i strukturę.
Spójność przede wszystkim - Gdy wybierzesz układ (według typu, według funkcji albo opisaną wyżej hybrydę), trzymaj się go w całym projekcie. Najgorsze jest przypadkowe mieszanie stylów.
Narzędzia pomagające w organizacji kodu
- ESLint - Pomaga utrzymać spójny styl kodu i wyłapać potencjalne błędy
- Prettier - Automatycznie formatuje kod według ustalonych reguł
- Import sorter - Sortuje importy dla lepszej czytelności
- Path aliases - Upraszcza importy używając aliasów jak @components, @utils
// tsconfig.json lub jsconfig.json
{
"compilerOptions": {
"baseUrl": "src",
"paths": {
"@components/*": ["shared/components/*"],
"@features/*": ["features/*"],
"@utils/*": ["shared/utils/*"],
"@hooks/*": ["shared/hooks/*"]
}
}
}
// Użycie
import Button from '@components/Button';
import { useAuth } from '@features/auth';
import { formatDate } from '@utils/formatDate';Dobrze zorganizowana struktura projektu znacznie ułatwia pracę, szczególnie w dużych zespołach i projektach. Pamiętaj, że nie ma jedynej "właściwej" struktury - najważniejsze, aby była spójna, logiczna dla Twojego zespołu i skalowalna wraz z rozwojem projektu.
Kod do tej lekcji: App.jsx
import React, { useState } from 'react';
// Demonstracja struktury projektu Vite + React
function ViteProjectDemo() {
const [activeFile, setActiveFile] = useState('App.jsx');
const fileStructure = [
{ name: 'node_modules/', type: 'folder', description: 'Zainstalowane pakiety' },
{ name: 'public/', type: 'folder', description: 'Pliki statyczne' },
{ name: ' vite.svg', type: 'file', description: 'Logo Vite' },
{ name: 'src/', type: 'folder', description: 'Kod źródłowy' },
{ name: ' assets/', type: 'folder', description: 'Zasoby (obrazy, fonty)' },
{ name: ' App.jsx', type: 'file', description: 'Główny komponent', active: true },
{ name: ' App.css', type: 'file', description: 'Style komponentu' },
{ name: ' main.jsx', type: 'file', description: 'Punkt wejściowy' },
{ name: ' index.css', type: 'file', description: 'Style globalne' },
{ name: 'index.html', type: 'file', description: 'Główny HTML (w katalogu głównym!)' },
{ name: 'vite.config.js', type: 'file', description: 'Konfiguracja Vite' },
{ name: 'package.json', type: 'file', description: 'Konfiguracja projektu' },
];
const fileContents = {
'App.jsx': `import { useState } from 'react'
import './App.css'
function App() {
const [count, setCount] = useState(0)
return (
<>
<h1>Vite + React</h1>
<div className="card">
<button onClick={() => setCount(c => c + 1)}>
count is {count}
</button>
</div>
</>
)
}
export default App`,
'main.jsx': `import React from 'react'
import ReactDOM from 'react-dom/client'
import App from './App.jsx'
import './index.css'
ReactDOM.createRoot(
document.getElementById('root')
).render(
<React.StrictMode>
<App />
</React.StrictMode>,
)`,
'vite.config.js': `import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
export default defineConfig({
plugins: [react()],
})`,
'package.json': `{
"name": "moja-aplikacja",
"version": "0.0.0",
"type": "module",
"scripts": {
"dev": "vite",
"build": "vite build",
"preview": "vite preview"
},
"dependencies": {
"react": "^18.2.0",
"react-dom": "^18.2.0"
},
"devDependencies": {
"@vitejs/plugin-react": "^4.2.0",
"vite": "^5.0.0"
}
}`
};
return (
<div style={{
fontFamily: 'Arial, sans-serif',
maxWidth: '1000px',
margin: '0 auto',
padding: '20px'
}}>
<header style={{
background: 'linear-gradient(135deg, #61dafb 0%, #21a1f1 100%)',
padding: '30px',
borderRadius: '12px',
color: 'white',
textAlign: 'center',
marginBottom: '30px'
}}>
<h1 style={{ margin: 0, fontSize: '2rem' }}>Vite + React</h1>
<p style={{ margin: '10px 0 0 0', opacity: 0.9 }}>
Struktura projektu i podstawowe pliki
</p>
</header>
<div style={{
backgroundColor: '#1e1e1e',
borderRadius: '8px',
padding: '20px',
marginBottom: '30px',
fontFamily: 'monospace'
}}>
<div style={{ color: '#888', marginBottom: '10px' }}>Terminal:</div>
<div style={{ color: '#00ff00' }}>$ npm create vite@latest moja-aplikacja -- --template react</div>
<div style={{ color: '#888', marginTop: '5px' }}>Scaffolding project in /moja-aplikacja...</div>
<div style={{ color: '#00ff00', marginTop: '5px' }}>Done. Now run: cd moja-aplikacja && npm install && npm run dev</div>
</div>
<div style={{ display: 'grid', gridTemplateColumns: '300px 1fr', gap: '20px' }}>
<div style={{
backgroundColor: '#252526',
borderRadius: '8px',
padding: '15px'
}}>
<h3 style={{ color: '#cccccc', margin: '0 0 15px 0', fontSize: '14px' }}>
EXPLORER
</h3>
{fileStructure.map((item, index) => (
<div
key={index}
onClick={() => item.type === 'file' && setActiveFile(item.name.trim())}
style={{
padding: '8px 10px',
color: item.type === 'folder' ? '#dcb67a' : '#9cdcfe',
cursor: item.type === 'file' ? 'pointer' : 'default',
backgroundColor: activeFile === item.name.trim() ? '#094771' : 'transparent',
borderRadius: '4px',
fontSize: '14px',
fontFamily: 'monospace'
}}
>
{item.type === 'folder' ? '▸' : '•'} {item.name}
</div>
))}
</div>
<div style={{
backgroundColor: '#1e1e1e',
borderRadius: '8px',
padding: '20px'
}}>
<div style={{
color: '#888',
fontSize: '12px',
marginBottom: '10px',
borderBottom: '1px solid #333',
paddingBottom: '10px'
}}>
{activeFile}
</div>
<pre style={{
color: '#d4d4d4',
margin: 0,
fontSize: '14px',
lineHeight: '1.5',
overflow: 'auto'
}}>
{fileContents[activeFile] || '// Wybierz plik z listy'}
</pre>
</div>
</div>
<div style={{
marginTop: '30px',
padding: '20px',
backgroundColor: '#fff3e0',
borderRadius: '8px'
}}>
<h3 style={{ color: '#e65100', marginTop: 0 }}>Komendy startowe</h3>
<div style={{ display: 'grid', gridTemplateColumns: 'repeat(2, 1fr)', gap: '15px' }}>
<div style={{ backgroundColor: 'white', padding: '15px', borderRadius: '8px' }}>
<code style={{ color: '#e65100' }}>npm run dev</code>
<p style={{ margin: '5px 0 0 0', fontSize: '14px', color: '#666' }}>
Uruchamia serwer deweloperski
</p>
</div>
<div style={{ backgroundColor: 'white', padding: '15px', borderRadius: '8px' }}>
<code style={{ color: '#e65100' }}>npm run build</code>
<p style={{ margin: '5px 0 0 0', fontSize: '14px', color: '#666' }}>
Buduje wersję produkcyjną
</p>
</div>
</div>
</div>
</div>
);
}
export default function App() {
return <ViteProjectDemo />;
}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. Jaki jest główny cel folderu src/ w projekcie React?
2. W którym folderze znajdują się główne pliki źródłowe React?
3. Gdzie w projekcie React utworzonym z Vite znajduje się plik index.html?
Zadania praktyczne w grze
- Układanie w pionie
Ułóż hierarchię plików aplikacji React:
- Klikanie w kolejności
Ułóż workflow developmentu React:
- Edytor kodu
Stwórz w pliku App.jsx podstawową strukturę komponentu: import React, komponent funkcyjny App zwracający JSX i eksport domyślny (export default).