Kurs JavaScript i React · Moduł 1: Podstawy React

Struktura projektu React

13 min czytania ·
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 projektu

Omó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.css

Struktura 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.js

Uż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.css

assets/

Zawiera wszystkie statyczne zasoby używane w aplikacji:

assets/
├── images/
│   ├── logo.png
│   └── background.jpg
├── fonts/
│   ├── roboto.ttf
│   └── open-sans.ttf
└── styles/
    ├── variables.css
    └── global.css

utils/

Funkcje pomocnicze i narzędzia używane w całej aplikacji:

utils/
├── formatDate.js
├── validation.js
└── helpers.js

services/

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 produktami

hooks/

Niestandardowe hooki React, które można używać w wielu miejscach aplikacji:

hooks/
├── useLocalStorage.js
├── useFetch.js
└── useForm.js

context/

Konteksty React używane do zarządzania globalnym stanem:

context/
├── AuthContext.js
├── ThemeContext.js
└── CartContext.js

Organizacja 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.css

Styled Components

Button/
└── Button.jsx  # Zawiera definicje styled-components

SCSS/SASS

Button/
├── Button.jsx
└── Button.scss

Dobre 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.js

Zalety:

  • 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.jsx

Zalety:

  • Ł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.jsx

Dlaczego 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.js

Dlaczego "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.js

Utils i services - camelCase

// DOBRZE - camelCase
formatDate.js
validateEmail.js
apiService.js
authService.js

// ŹLE - inne konwencje
FormatDate.js
validate-email.js
API_Service.js

Gdzie 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 hook

Type-based approach:

hooks/
├── useAuth.js
├── useSession.js
├── useProducts.js
├── useLocalStorage.js
├── useDebounce.js
└── useFetch.js

Utils (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ółdzielone

Type-based approach:

utils/
├── formatPrice.js
├── formatDate.js
├── validatePassword.js
├── filterProducts.js
├── debounce.js
└── cloneDeep.js

Types (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.ts

Opcja 2: Scentralizowane typy:

types/
├── user.types.ts
├── product.types.ts
├── cart.types.ts
└── api.types.ts

Opcja 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.ts

Przykł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.md

Zasady organizacji plików

  1. 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/
  1. 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
  1. 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
  1. 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

  1. 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.

  2. Refaktoryzuj, gdy zajdzie potrzeba - Dostosowuj strukturę w miarę rozwoju projektu. Jeśli folder ma więcej niż 10-15 plików, rozważ jego podział.

  3. 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ł.

  4. 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.

  5. Dokumentuj - Dodaj README.md do głównych katalogów, aby wyjaśnić ich przeznaczenie i strukturę.

  6. 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

  1. ESLint - Pomaga utrzymać spójny styl kodu i wyłapać potencjalne błędy
  2. Prettier - Automatycznie formatuje kod według ustalonych reguł
  3. Import sorter - Sortuje importy dla lepszej czytelności
  4. 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. 1. Jaki jest główny cel folderu src/ w projekcie React?

  2. 2. W którym folderze znajdują się główne pliki źródłowe React?

  3. 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).

  1. PytanieFolder src w projekcie React
  2. PytanieStruktura projektu React
  3. PytaniePlik index.html w projekcie Vite
  4. Ułóż w kolejnościProces: Struktura aplikacji
  5. Kliknij w kolejnościSortowanie: Proces deweloperski
  6. Zadanie z kodemPraktyka: Struktura pliku komponentu

Przydatne artykuły