Kurs Next.js · Moduł 1: Konfiguracja Next.js
Struktura katalogów i plików w Next.js (app/ vs pages/)
W tej lekcji9
W Metropolii Quantum inżynierowie projektują zaawansowane systemy transportu, które mogą działać zarówno na klasycznych drogach, jak i na nowych szlakach kwantowej teleportacji. Podobnie, Next.js oferuje dwa równoległe systemy routingu: tradycyjny Pages Router i nowoczesny App Router. W tym module szczegółowo przeanalizujemy różnice między tymi dwoma podejściami i zrozumiemy, jak organizować pliki i katalogi w naszych projektach.
Dwie filozofie routingu w Next.js
Next.js pierwotnie korzystał z routingu opartego na plikach w folderze pages/. W Next.js 13 wprowadzono nowy system routingu oparty na folderze app/. Ta ewolucja przypomina przejście od klasycznych systemów transportu do kwantowej teleportacji w Metropolii Quantum - nowa technologia jest bardziej zaawansowana, ale obie nadal współistnieją.
Pages Router: Klasyczne podejście
Pages Router to oryginalny system routingu w Next.js. Jest prosty, dobrze udokumentowany i nadal szeroko używany. W tej konwencji każdy plik JavaScript lub TypeScript w katalogu pages/ automatycznie staje się ścieżką w aplikacji.
pages/
├── index.js # Trasa: /
├── about.js # Trasa: /about
├── contact.tsx # Trasa: /contact
├── products/
│ ├── index.js # Trasa: /products
│ └── [id].js # Trasa: /products/:id (dynamiczna)
└── api/
└── hello.js # Endpoint API: /api/helloW tym systemie:
- Pliki bezpośrednio mapują się na ścieżki URL
- Dynamiczne segmenty ścieżki są oznaczane nawiasami kwadratowymi
[param] - Specjalny katalog
api/służy do obsługi endpointów API - Każdy plik eksportuje domyślnie komponent React lub funkcję obsługi API
App Router: Nowoczesne podejście
App Router, wprowadzony w Next.js 13 i dopracowany w wersji 15, reprezentuje nowe podejście oparte na React Server Components. Jest to jak przejście od tradycyjnych pojazdów do teleportacji kwantowej - fundamentalna zmiana w sposobie myślenia o aplikacjach webowych.
app/
├── layout.tsx # Główny układ (wymagany)
├── page.tsx # Trasa: /
├── about/
│ └── page.tsx # Trasa: /about
├── blog/
│ ├── page.tsx # Trasa: /blog
│ ├── layout.tsx # Układ specyficzny dla /blog i jego podścieżek
│ └── [slug]/
│ └── page.tsx # Trasa: /blog/:slug (dynamiczna)
└── api/
└── users/
└── route.ts # Endpoint API: /api/usersW App Routerze:
- Tylko katalogi definiują ścieżki, a specjalne pliki wewnątrz tych katalogów pełnią konkretne funkcje
- Plik
page.tsxrenderuje komponent strony dla danej ścieżki - Plik
layout.tsxdefiniuje współdzielony układ dla wszystkich stron w katalogu i jego podkatalogach - Dynamiczne segmenty nadal używają nawiasów kwadratowych:
[param] - Endpointy API są tworzone przy użyciu plików
route.ts
Nazewnictwo plików i konwencje w App Routerze
App Router wprowadza "konwencję ponad konfiguracją" z szeregiem specjalnych plików, które mają określone role. Jest to jak wyspecjalizowane moduły w systemach Metropolii Quantum - każdy z określoną funkcją w ogólnej architekturze.
Podstawowe pliki specjalne:
page.tsx: Renderuje interfejs użytkownika trasy i sprawia, że ścieżka jest publicznie dostępna.
// app/dashboard/page.tsx export default function DashboardPage() { return ( <section> <h1>Panel kontrolny Metropolii Quantum</h1> <p>Witaj w centrum dowodzenia!</p> </section> ); }layout.tsx: Definiuje współdzielony interfejs dla segmentu i jego dzieci.
// app/dashboard/layout.tsx export default function DashboardLayout({ children, }: { children: React.ReactNode; }) { return ( <div className="dashboard-layout"> <nav className="dashboard-sidebar"> {/* Nawigacja panelu bocznego */} </nav> <main className="dashboard-main">{children}</main> </div> ); }route.ts: Tworzy endpoint API przy użyciu nowego API obsługi żądań.
// app/api/status/route.ts import { NextResponse } from 'next/server'; export async function GET() { return NextResponse.json({ status: 'online', systemsOperational: 15, time: new Date().toISOString() }); } export async function POST(request: Request) { const data = await request.json(); // Przetwarzanie danych... return NextResponse.json({ success: true }); }loading.tsx: Tworzy interfejs ładowania z React Suspense.
// app/dashboard/loading.tsx export default function DashboardLoading() { return ( <div className="dashboard-loading"> <div className="spinner"></div> <p>Ładowanie danych systemowych Metropolii...</p> </div> ); }error.tsx: Tworzy interfejs obsługi błędów z React Error Boundary.
'use client'; // Komponenty obsługi błędów muszą być komponentami klienckimi import { useEffect } from 'react'; export default function DashboardError({ error, reset, }: { error: Error; reset: () => void; }) { useEffect(() => { // Logowanie błędu do systemu monitorowania console.error(error); }, [error]); return ( <div className="error-container"> <h2>Wystąpił błąd w systemach Metropolii!</h2> <p>{error.message}</p> <button onClick={reset}>Spróbuj ponownie</button> </div> ); }not-found.tsx: Tworzy interfejs dla nieznalezionego zasobu (404).
// app/not-found.tsx export default function NotFound() { return ( <div className="not-found"> <h2>Strefa nieznana</h2> <p>Nie znaleziono modułu Metropolii Quantum o takim identyfikatorze.</p> <a href="/">Powrót do centrum dowodzenia</a> </div> ); }
Zaawansowane funkcje App Routera
App Router wprowadza kilka zaawansowanych funkcji organizacyjnych, które przypominają zaawansowane systemy transportu w Metropolii Quantum - pozwalają na bardziej skomplikowane i elastyczne trasy.
1. Grupy tras (Route Groups)
Grupy tras pozwalają na organizowanie plików bez wpływania na strukturę URL. Są oznaczane przez ujęcie nazwy katalogu w nawiasy: (nazwa-grupy).
app/
├── (marketing)/ # Grupa tras (nie wpływa na ścieżkę URL)
│ ├── about/
│ │ └── page.tsx # Trasa: /about
│ └── contact/
│ └── page.tsx # Trasa: /contact
└── (dashboard)/ # Inna grupa tras
├── layout.tsx # Współdzielony układ dla tras dashboard
├── page.tsx # Trasa: /
└── stats/
└── page.tsx # Trasa: /statsGrupy tras są jak dzielnice w Metropolii Quantum - pomagają organizować strukturę miasta, ale nie wpływają na adresy.
2. Trasy równoległe (Parallel Routes)
Trasy równoległe pozwalają na równoczesne renderowanie wielu stron w tym samym widoku, co jest przydatne dla złożonych układów. Są oznaczane przez nazwę slotu ze znakiem "@": @nazwa-slotu.
app/
├── layout.tsx # Główny układ
├── page.tsx # Główna strona
└── dashboard/
├── layout.tsx # Układ z wieloma slotami
│ // layout.tsx definiuje sloty {children, @stats, @notifications}
├── page.tsx # Domyślna zawartość dla slotu głównego
├── @stats/
│ ├── page.tsx # Zawartość dla slotu @stats
│ └── default.tsx # Wymagany w Next.js 16 (np. zwraca null)
└── @notifications/
├── page.tsx # Zawartość dla slotu @notifications
└── default.tsx # Wymagany w Next.js 16 (np. zwraca null)W Next.js 16 każdy slot musi mieć plik default.tsx (np. zwracający null albo wywołujący notFound()), inaczej next build zakończy się błędem.
// app/dashboard/layout.tsx
export default function DashboardLayout({
children,
stats,
notifications,
}: {
children: React.ReactNode;
stats: React.ReactNode;
notifications: React.ReactNode;
}) {
return (
<div className="dashboard-grid">
<main>{children}</main>
<aside className="stats-panel">{stats}</aside>
<section className="notifications-panel">{notifications}</section>
</div>
);
}Trasy równoległe to jak równoległe wymiary w Metropolii Quantum - różne rzeczywistości dostępne jednocześnie.
3. Przechwytujące trasy (Intercepting Routes)
Pozwalają na "przechwycenie" trasy i wyświetlenie jej inaczej, co jest idealne dla modali, które zachowują kontekst nawigacji. Są oznaczane przez nazwę segmentu ze znakiem "(.)": (.)nazwa, (..)nazwa lub (...)nazwa.
app/
├── layout.tsx
├── page.tsx # Trasa: /
└── dashboard/
├── layout.tsx
├── page.tsx # Trasa: /dashboard
└── projects/
├── layout.tsx # Renderuje {children} i {modal}
├── page.tsx # Trasa: /dashboard/projects
├── [id]/
│ └── page.tsx # Trasa: /dashboard/projects/:id
├── create/
│ └── page.tsx # Trasa: /dashboard/projects/create (pełna strona)
└── @modal/
├── default.tsx # Zwraca null, gdy modal jest zamknięty
└── (.)create/
└── page.tsx # Modal nad listą przy przejściu linkiemPrzy przejściu linkiem z listy Next.js pokaże przechwyconą stronę w slocie @modal nad listą, a po odświeżeniu lub wejściu bezpośrednio z adresu wyświetli pełną stronę create/page.tsx.
Przechwytujące trasy są jak kwantowe skróty w Metropolii Quantum - pozwalają na szybki dostęp do zasobów bez zmiany kontekstu.
Organizacja kodu w Next.js 16
Oprócz struktury routingu Next.js 16 sugeruje określone sposoby organizacji kodu. Jest to jak planowanie dzielnic w Metropolii Quantum - właściwa organizacja zwiększa efektywność i czytelność.
Współdzielone komponenty i zasoby
Komponenty, które są używane w wielu miejscach, powinny być zorganizowane w spójny sposób. Oto zalecana struktura:
src/
├── app/ # Aplikacja z App Routerem
│ ├── layout.tsx
│ └── page.tsx
├── components/ # Współdzielone komponenty
│ ├── ui/ # Podstawowe komponenty UI
│ │ ├── Button.tsx
│ │ └── Card.tsx
│ └── features/ # Komponenty specyficzne dla funkcji
│ ├── dashboard/
│ └── auth/
├── lib/ # Współdzielone funkcje i klasy
│ ├── api/
│ └── utils/
├── hooks/ # Niestandardowe hooki React
│ ├── useAuth.ts
│ └── useLocalStorage.ts
└── styles/ # Style globalne
└── globals.cssCo-location vs. Centralizacja
Next.js 16 i App Router wspierają podejście "co-location", gdzie pliki związane z konkretną trasą są umieszczane blisko siebie. Jest to jak mikrodystrykty w Metropolii Quantum - wszystko, czego potrzebujesz, jest blisko.
app/
└── dashboard/
├── page.tsx
├── loading.tsx # Ładowanie dla tej trasy
├── error.tsx # Obsługa błędów dla tej trasy
├── layout.tsx # Układ dla tej trasy
├── actions.ts # Server Actions dla tej trasy
├── components/ # Komponenty specyficzne dla tej trasy
│ ├── StatusCard.tsx
│ └── DashboardNav.tsx
└── styles/ # Style specyficzne dla tej trasy
└── dashboard.module.cssPorównanie App Routera i Pages Routera
Teraz, gdy poznaliśmy oba systemy routingu, porównajmy je - podobnie jak inżynierowie Metropolii Quantum mogliby porównywać klasyczny transport z teleportacją kwantową.
Renderowanie
Pages Router:
- Domyślnie każda strona jest prerenderowana do HTML (automatyczna optymalizacja statyczna), a w przeglądarce hydratowana
- SSR i SSG dostępne przez getServerSideProps i getStaticProps
- Stosunkowo proste modele danych
App Router:
- Domyślnie Server Components
- Wybór między Server i Client Components
- Bardziej zaawansowany model przepływu danych
- Streaming renderowania
W Pages Routerze dane strony pobiera funkcja eksportowana obok komponentu, np. getStaticProps, którą Next.js wywołuje raz, podczas budowania:
// pages/posts.js (Pages Router)
export async function getStaticProps() {
const posts = await getPosts();
return { props: { posts } };
}Funkcja getServerSideProps ma tę samą budowę, ale Next.js wywołuje ją przy każdym żądaniu.
Stany ładowania
Pages Router:
- Ręczne zarządzanie stanami ładowania
- Często wykorzystuje zewnętrzne biblioteki
App Router:
- Wbudowane komponenty loading.tsx
- Integracja z React Suspense
- Automatyczne wskaźniki ładowania
Obsługa błędów
Pages Router:
- Ręczne zarządzanie błędami
- Ogólny komponent dla błędów 500
App Router:
- Komponenty error.tsx z granularną obsługą błędów
- Integracja z React Error Boundary
- Możliwość naprawy/ponowienia po błędzie
Układy
Pages Router:
- Ręczne tworzenie układów z komponentem _app.js
- Jeden układ dla całej aplikacji
- Zagnieżdżone układy wymagają dodatkowej pracy
App Router:
- Wbudowany system układów poprzez layout.tsx
- Możliwość tworzenia zagnieżdżonych układów
- Współdzielenie układów jest proste i intuicyjne
Kiedy używać którego systemu routingu?
Wybór między App Routerem a Pages Routerem przypomina wybór między kwantową teleportacją a tradycyjnym transportem w Metropolii Quantum - zależy od konkretnych potrzeb.
Używaj App Routera, gdy:
- Tworzysz nowy projekt od podstaw
- Chcesz korzystać z najnowszych funkcji React i Next.js
- Potrzebujesz zaawansowanych możliwości układu i organizacji
- Zależy Ci na lepszej wydajności i strumieniowym renderowaniu (streamingu)
- Chcesz korzystać z React Server Components
Używaj Pages Routera, gdy:
- Masz istniejący projekt oparty na Pages Routerze
- Potrzebujesz prostszego modelu mentalnego
- Używasz bibliotek, które nie są jeszcze kompatybilne z App Routerem
- Chcesz używać gotowych wzorców i rozwiązań
Migracja z Pages Routera do App Routera
Jeśli masz istniejący projekt używający Pages Routera, możesz stopniowo migrować do App Routera. Jest to jak modernizacja dzielnic w Metropolii Quantum - nie musisz przebudowywać wszystkiego naraz.
Next.js 16 pozwala na współistnienie obu systemów. Możesz zacząć używać app/ dla nowych funkcji, jednocześnie zachowując istniejące strony w pages/.
.
├── app/ # Nowe funkcje używające App Router
│ ├── new-feature/
│ │ └── page.tsx # /new-feature
│ └── layout.tsx
└── pages/ # Istniejące strony używające Pages Router
├── index.js # /
└── about.js # /aboutWażne uwagi dotyczące migracji:
- Ścieżki w
app/mają priorytet nad ścieżkami wpages/, ale ten sam adres nie może istnieć w obu katalogach naraz: Next.js zgłosi błąd podczas budowania - Obie struktury używają tej samej konfiguracji Next.js
- Możesz stopniowo przenosić strony z
pages/doapp/
Najlepsze praktyki organizacji plików
Niezależnie od wybranego systemu routingu warto trzymać się pewnych najlepszych praktyk:
Struktura zorientowana na funkcje: Organizuj komponenty i kod wokół funkcji biznesowych, a nie według typów technicznych.
src/ ├── features/ │ ├── auth/ │ │ ├── components/ │ │ ├── hooks/ │ │ └── utils/ │ └── dashboard/ │ ├── components/ │ ├── hooks/ │ └── utils/Modułowe podejście: Traktuj każdą funkcjonalność jako izolowany moduł z jasno określonym API.
Spójna konwencja nazewnictwa: Ustal konwencje i trzymaj się ich w całym projekcie.
- Pliki komponentów: PascalCase (Button.tsx)
- Hooki: camelCase z przedrostkiem "use" (useAuth.ts)
- Pomocnicze funkcje: camelCase (formatDate.ts)
Importy względne vs. absolutne: Używaj aliasów importu (
@/) dla lepszej czytelności i łatwiejszego przenoszenia plików.Kolokacja testów: Umieszczaj testy blisko testowanych komponentów.
src/ ├── components/ │ ├── Button.tsx │ └── Button.test.tsx
Podsumowanie
Struktura katalogów i plików w Next.js 16 jest jak architektura Metropolii Quantum - z odpowiednim planowaniem może być zarówno elegancka, jak i funkcjonalna. App Router wprowadza bardziej zaawansowany, ale także bardziej elastyczny model organizacji aplikacji, podczas gdy Pages Router oferuje prostsze i bardziej bezpośrednie podejście.
Wybór między nimi zależy od specyficznych potrzeb projektu, ale w nowych projektach zaleca się korzystanie z App Routera, aby wykorzystać najnowsze funkcje i optymalizacje. Pamiętaj, że dobra organizacja projektu to klucz do łatwej konserwacji i rozszerzalności w przyszłości.
W kolejnej lekcji zagłębimy się w system komponentów Next.js 16, szczególnie w różnice między Client Components a Server Components, które są fundamentalną częścią App Routera.
Kod do tej lekcji: App.tsx
// Props i State - Metropolis Quantum
import React, { useState } from 'react';
console.log("Props i State w React");
console.log("Zarządzanie danymi w Quantum City\n");
// ==========================================
// 1. PROPS - Przekazywanie Danych
// ==========================================
console.log("=== 1. PROPS - właściwości ===");
interface UserCardProps {
name: string;
role: string;
level: number;
avatar: string;
}
const UserCard: React.FC<UserCardProps> = ({ name, role, level, avatar }) => {
return (
<div style={{
background: 'rgba(255, 255, 255, 0.1)',
padding: '20px',
borderRadius: '12px',
border: '2px solid #64ffda',
display: 'flex',
alignItems: 'center',
gap: '15px',
marginBottom: '15px'
}}>
<div style={{ fontSize: '3rem' }}>{avatar}</div>
<div>
<h3 style={{ color: '#64ffda', margin: '0 0 5px 0' }}>{name}</h3>
<p style={{ margin: '5px 0', color: '#b0bec5' }}>Rola: {role}</p>
<p style={{ margin: '5px 0', color: '#ff9800' }}>Poziom: {level}</p>
</div>
</div>
);
};
// ==========================================
// 2. STATE - Stan Komponentu
// ==========================================
console.log("\n=== 2. STATE - hook useState ===");
function QuantumCounter() {
// useState zwraca [wartość, funkcję do zmiany wartości]
const [energy, setEnergy] = useState<number>(50);
const [isCharging, setIsCharging] = useState<boolean>(false);
const charge = () => {
if (energy < 100) {
setEnergy(energy + 10);
setIsCharging(true);
setTimeout(() => setIsCharging(false), 300);
console.log(`Ładowanie energii: ${energy + 10}%`);
}
};
const discharge = () => {
if (energy > 0) {
setEnergy(energy - 10);
console.log(`Rozładowanie energii: ${energy - 10}%`);
}
};
const reset = () => {
setEnergy(50);
console.log("Reset energii do 50%");
};
const getEnergyColor = () => {
if (energy > 70) return '#4caf50';
if (energy > 30) return '#ff9800';
return '#f44336';
};
return (
<div style={{
background: 'rgba(124, 77, 255, 0.2)',
padding: '20px',
borderRadius: '12px',
border: '2px solid #7c4dff'
}}>
<h3 style={{ color: '#7c4dff' }}>Kwantowy generator energii</h3>
<div style={{
background: 'rgba(0, 0, 0, 0.5)',
padding: '15px',
borderRadius: '8px',
marginBottom: '15px'
}}>
<div style={{
fontSize: '2rem',
textAlign: 'center',
color: getEnergyColor(),
marginBottom: '10px'
}}>
{energy}%
</div>
<div style={{
width: '100%',
height: '20px',
background: 'rgba(255, 255, 255, 0.1)',
borderRadius: '10px',
overflow: 'hidden'
}}>
<div style={{
width: `${energy}%`,
height: '100%',
background: `linear-gradient(90deg, ${getEnergyColor()}, #64ffda)`,
transition: 'all 0.3s ease',
transform: isCharging ? 'scale(1.05)' : 'scale(1)'
}}></div>
</div>
</div>
<div style={{ display: 'flex', gap: '10px', justifyContent: 'center' }}>
<button
onClick={charge}
disabled={energy >= 100}
style={{
background: energy >= 100 ? '#555' : 'linear-gradient(45deg, #4caf50, #8bc34a)',
color: 'white',
border: 'none',
padding: '10px 20px',
borderRadius: '6px',
cursor: energy >= 100 ? 'not-allowed' : 'pointer',
fontWeight: 'bold'
}}
>
Naładuj
</button>
<button
onClick={discharge}
disabled={energy <= 0}
style={{
background: energy <= 0 ? '#555' : 'linear-gradient(45deg, #f44336, #e91e63)',
color: 'white',
border: 'none',
padding: '10px 20px',
borderRadius: '6px',
cursor: energy <= 0 ? 'not-allowed' : 'pointer',
fontWeight: 'bold'
}}
>
Rozładuj
</button>
<button
onClick={reset}
style={{
background: 'linear-gradient(45deg, #607d8b, #90a4ae)',
color: 'white',
border: 'none',
padding: '10px 20px',
borderRadius: '6px',
cursor: 'pointer',
fontWeight: 'bold'
}}
>
Resetuj
</button>
</div>
</div>
);
}
// ==========================================
// 3. Props i State razem
// ==========================================
console.log("\n=== 3. Props i State razem ===");
interface SystemStatusProps {
systemName: string;
initialStatus: 'online' | 'offline' | 'maintenance';
}
const SystemStatus: React.FC<SystemStatusProps> = ({ systemName, initialStatus }) => {
const [status, setStatus] = useState(initialStatus);
const [uptime, setUptime] = useState(0);
const toggleStatus = () => {
const statuses: Array<'online' | 'offline' | 'maintenance'> = ['online', 'offline', 'maintenance'];
const currentIndex = statuses.indexOf(status);
const nextStatus = statuses[(currentIndex + 1) % statuses.length];
setStatus(nextStatus);
setUptime(0);
console.log(`Status systemu ${systemName} zmieniony na: ${nextStatus}`);
};
const getStatusColor = () => {
switch(status) {
case 'online': return '#4caf50';
case 'offline': return '#f44336';
case 'maintenance': return '#ff9800';
}
};
return (
<div style={{
background: 'rgba(255, 255, 255, 0.1)',
padding: '15px',
borderRadius: '10px',
border: `2px solid ${getStatusColor()}`,
marginBottom: '15px'
}}>
<div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
<div>
<h4 style={{ margin: '0 0 10px 0', color: '#64ffda' }}>{systemName}</h4>
<div style={{ display: 'flex', alignItems: 'center', gap: '10px' }}>
<div style={{
width: '12px',
height: '12px',
borderRadius: '50%',
background: getStatusColor(),
boxShadow: `0 0 10px ${getStatusColor()}`
}}></div>
<span style={{ color: getStatusColor(), textTransform: 'uppercase', fontWeight: 'bold' }}>
{status}
</span>
</div>
</div>
<button
onClick={toggleStatus}
style={{
background: 'linear-gradient(45deg, #2196f3, #21cbf3)',
color: 'white',
border: 'none',
padding: '8px 16px',
borderRadius: '6px',
cursor: 'pointer',
fontWeight: 'bold'
}}
>
Zmień status
</button>
</div>
</div>
);
};
// ==========================================
// Główna aplikacja
// ==========================================
function App() {
const citizens = [
{ name: 'Alex Quantum', role: 'Główny architekt', level: 42, avatar: '' },
{ name: 'Nova Star', role: 'Analityk danych', level: 38, avatar: '' },
{ name: 'Cypher Neo', role: 'Ekspert ds. bezpieczeństwa', level: 45, avatar: '' }
];
return (
<div style={{
padding: '20px',
background: 'linear-gradient(135deg, #0f0f23 0%, #1a1a2e 100%)',
minHeight: '100vh',
color: 'white'
}}>
<h1 style={{ textAlign: 'center', color: '#64ffda' }}>Panel sterowania Metropolii</h1>
<div style={{ marginTop: '30px' }}>
<h2 style={{ color: '#7c4dff' }}>Mieszkańcy (demo Props)</h2>
{citizens.map((citizen, index) => (
<UserCard
key={index}
name={citizen.name}
role={citizen.role}
level={citizen.level}
avatar={citizen.avatar}
/>
))}
</div>
<div style={{ marginTop: '30px' }}>
<h2 style={{ color: '#7c4dff' }}>System energii (demo State)</h2>
<QuantumCounter />
</div>
<div style={{ marginTop: '30px' }}>
<h2 style={{ color: '#7c4dff' }}>Status systemów (Props + State)</h2>
<SystemStatus systemName="Quantum Core" initialStatus="online" />
<SystemStatus systemName="Neural Network" initialStatus="maintenance" />
<SystemStatus systemName="Transport Grid" initialStatus="offline" />
</div>
<div style={{
marginTop: '30px',
background: 'rgba(100, 255, 218, 0.1)',
padding: '20px',
borderRadius: '10px',
borderLeft: '4px solid #64ffda'
}}>
<h3>Props a State:</h3>
<ul style={{ lineHeight: '1.8' }}>
<li><strong>Props</strong>: Przekazywane z rodzica, tylko do odczytu, jak parametry funkcji</li>
<li><strong>State</strong>: Wewnętrzny stan komponentu, można modyfikować, re-renderuje komponent</li>
<li><strong>Props + State</strong>: Najczęściej używane razem w dynamicznych interfejsach</li>
</ul>
</div>
</div>
);
}
export default App;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. Co oznacza 'deklaratywne programowanie' w kontekście React?
2. Komponenty React mogą być:
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż ścieżkę do dynamicznej strony posta w Next.js
- Edytor kodu
Utwórz komponent strony About dla pliku pages/about.js (export default function About). Strona ma wyświetlać nagłówek <h1> lub <h2> z nazwą firmy i akapit <p> z informacjami o firmie.