Kurs Next.js · Moduł 1: Konfiguracja Next.js
Wprowadzenie do React i Next.js - historia, zalety, ekosystem
W tej lekcji7
Witaj w Metropolii Quantum, centrum technologicznym roku 2150, gdzie budynki sięgają nieba, pojazdy unoszą się w powietrzu, a wszechobecna sieć kwantowa łączy wszystkie aspekty codziennego życia. Technologia jest tu integralną częścią społeczeństwa, podobnie jak React i Next.js są fundamentalnymi składnikami nowoczesnego ekosystemu webowego.
Narodziny technologii React
W historii rozwoju technologii webowych React był jak pierwszy sprawny silnik antygrawitacyjny - zrewolucjonizował sposób, w jaki konstruujemy interfejsy użytkownika. Stworzony w 2011 roku przez inżyniera Facebooka (obecnie Meta) i udostępniony jako open source w 2013 roku, React wprowadził przełomową koncepcję: deklaratywne komponenty z wirtualnym DOM.
React rozwiązał jeden z najważniejszych problemów rozwoju aplikacji webowych - złożoność aktualizacji interfejsu użytkownika. Zamiast bezpośrednio manipulować DOM (co było kosztowne i podatne na błędy), React pozwolił deweloperom myśleć w kategoriach stanu i komponentów:
// Prosty komponent React
function WelcomePanel() {
const [userName, setUserName] = React.useState("Obywatelu");
return (
<div className="quantum-panel">
<h2>Witaj, {userName}!</h2>
<p>Terminal Metropolii Quantum do Twoich usług.</p>
<button onClick={() => setUserName("Administratorze")}>
Zaloguj się
</button>
</div>
);
}Komponent powyżej to jak inteligentny panel sterowania w Metropolii Quantum - automatycznie reaguje na zmiany stanu (w tym przypadku userName), bez konieczności ręcznego sterowania każdym elementem interfejsu.
Starszy kod Reacta używa też komponentów klasowych (class Panel extends React.Component). Nadal działają, ale nowe komponenty pisze się jako funkcje.
Ewolucja do Next.js
Pomimo swoich zalet React był tylko biblioteką interfejsu użytkownika. Deweloperzy wciąż musieli samodzielnie konfigurować routing, optymalizację wydajności, renderowanie po stronie serwera i wiele innych aspektów.
Next.js pojawił się w 2016 roku jako framework zbudowany na bazie Reacta, dostarczający gotowe rozwiązania dla tych problemów. Można to porównać do przejścia od prototypu silnika antygrawitacyjnego do w pełni funkcjonalnego pojazdu latającego w Metropolii Quantum.
Najważniejsze cechy Next.js:
Renderowanie hybrydowe - możliwość renderowania zarówno po stronie serwera (SSR), statycznie (SSG), jak i po stronie klienta
Routing oparty na systemie plików - tworzenie ścieżek aplikacji poprzez strukturę folderów
Automatyczny code splitting - dzielenie kodu na mniejsze części, ładowane tylko wtedy, gdy są potrzebne
Optymalizacja obrazów - automatyczne przetwarzanie i serwowanie obrazów w optymalnych formatach
Zero-config - działa natychmiast po instalacji, z minimalną konfiguracją
API Routes - tworzenie endpointów API w tym samym projekcie co frontend
Next.js 16 i App Router
W Next.js 16 zalecanym routerem jest App Router - rewolucyjna zmiana, która pojawiła się w Next.js 13 i oznacza całkowicie nowe podejście do organizacji aplikacji (starszy Pages Router nadal działa). Jest to jak przejście od tradycyjnych pojazdów latających do teleportacji kwantowej w Metropolii Quantum - fundamentalna zmiana paradygmatu.
App Router wykorzystuje najnowsze funkcje React 19.2, w tym React Server Components, które zmieniają tradycyjny model aplikacji webowych. Zamiast traktować całą aplikację jako jednostkę renderowaną po stronie klienta, App Router pozwala na elastyczne mieszanie komponentów renderowanych na serwerze i kliencie.
// app/dashboard/page.tsx - Server Component
export default async function DashboardPage() {
// Ten kod wykonuje się TYLKO na serwerze
const dashboardData = await fetchDashboardData();
return (
<main className="quantum-dashboard">
<h1>Panel Kontrolny Metropolii Quantum</h1>
<StatusPanel data={dashboardData.status} />
<InteractiveControls /> {/* To będzie komponent kliencki */}
</main>
);
}// app/dashboard/interactive-controls.tsx - Client Component
"use client"; // Ta dyrektywa oznacza komponent kliencki
import { useState } from 'react';
export default function InteractiveControls() {
// Ten kod wykonuje się w przeglądarce użytkownika
const [activeSystem, setActiveSystem] = useState('energy');
return (
<div className="control-panel">
<h2>System: {activeSystem}</h2>
<button onClick={() => setActiveSystem('transport')}>
Transport
</button>
<button onClick={() => setActiveSystem('energy')}>
Energia
</button>
<button onClick={() => setActiveSystem('security')}>
Bezpieczeństwo
</button>
</div>
);
}Ekosystem React i Next.js
Ekosystem React i Next.js to jak zaawansowana infrastruktura Metropolii Quantum - rozbudowana, zintegrowana i ciągle ewoluująca. Oto kluczowe elementy tego ekosystemu:
Biblioteki zarządzania stanem:
- Redux - kompleksowe rozwiązanie dla złożonych aplikacji
- Zustand - lżejsza, prostsza alternatywa
- Jotai - atomowa architektura stanu
- React Query / SWR - zarządzanie stanem serwerowym
Biblioteki stylizacji:
- Tailwind CSS - system klas użytkowych
- Styled Components / Emotion - CSS-in-JS
- CSS Modules - wbudowane w Next.js
- Chakra UI / MUI - gotowe komponenty UI
Testowanie:
- Jest - framework testowy
- React Testing Library - testowanie komponentów
- Cypress / Playwright - testy end-to-end
Narzędzia deweloperskie:
- ESLint - statyczna analiza kodu
- Prettier - formatowanie kodu
- TypeScript - typowanie statyczne
- Next.js DevTools - narzędzia deweloperskie Next.js
Zalety używania React i Next.js
Używanie React i Next.js w projektach webowych przynosi korzyści podobne do tych, jakie mieszkańcy Metropolii Quantum czerpią z zaawansowanej infrastruktury miasta:
Wydajność - optymalizacje takie jak code splitting, wstępne ładowanie, optymalizacja obrazów
Skalowalność - architektura oparta na komponentach ułatwia zarządzanie dużymi aplikacjami
Doświadczenie dewelopera - szybka pętla zwrotna dzięki hot reloadingowi, jasna struktura projektu
SEO - renderowanie po stronie serwera i generowanie statyczne poprawiają indeksowanie przez wyszukiwarki
Ekosystem - bogaty wybór bibliotek i narzędzi
Społeczność - ogromna, aktywna społeczność i dokumentacja
Struktura projektu Next.js z App Routerem
W App Routerze struktura projektu przypomina mapy dzielnic i systemy transportowe Metropolii Quantum - wszystko ma swoje miejsce i przeznaczenie:
app/ # Główny katalog aplikacji
├── layout.tsx # Główny układ aplikacji
├── page.tsx # Strona główna
├── globals.css # Style globalne
├── dashboard/ # Trasa /dashboard
│ ├── layout.tsx # Układ dla całej sekcji dashboard
│ ├── page.tsx # Strona /dashboard
│ └── analytics/ # Trasa /dashboard/analytics
│ └── page.tsx # Strona /dashboard/analytics
├── auth/ # Trasa /auth
│ ├── login/ # Trasa /auth/login
│ │ └── page.tsx # Strona /auth/login
│ └── register/ # Trasa /auth/register
│ └── page.tsx # Strona /auth/register
└── api/ # Trasy API
└── status/ # Endpoint /api/status
└── route.ts # Obsługa API dla /api/statusW tej strukturze nawigacja jest intuicyjna, a komponenty współdzielone są automatycznie między stronami. Jest to ogromna zaleta w porównaniu z tradycyjnymi aplikacjami React, gdzie zarządzanie routingiem mogło być skomplikowane.
Podsumowanie
React i Next.js stanowią potężny duet w nowoczesnym rozwoju aplikacji webowych, podobnie jak sieć kwantowa i zaawansowana infrastruktura stanowią rdzeń funkcjonowania Metropolii Quantum.
React dostarcza model komponentów i zarządzania stanem, który czyni tworzenie interfejsów użytkownika bardziej przewidywalnym i łatwiejszym w utrzymaniu. Next.js dodaje strukturę, optymalizacje i narzędzia, które przekształcają React w kompletną platformę do budowania aplikacji webowych.
W miarę jak będziemy zagłębiać się w kolejne moduły, poznasz praktyczne zastosowania tych technologii, podobnie jak odkrywając Metropolię Quantum, poznasz wszystkie jej zaawansowane systemy.
Kod do tej lekcji: App.tsx
// React i Next.js - Metropolis Quantum
import React, { useState, useEffect } from 'react';
import './App.css';
console.log("Witaj w Metropolis Quantum!");
console.log("Poznajemy React i Next.js - przyszłość web developmentu\n");
// ===========================================
// 1. Komponenty Reacta - fundamenty
// ===========================================
console.log("=== 1. KOMPONENTY REACTA ===");
// Funkcyjny komponent React
const QuantumButton: React.FC<{
children: React.ReactNode;
onClick: () => void;
variant?: 'primary' | 'secondary' | 'quantum';
}> = ({ children, onClick, variant = 'primary' }) => {
const [isActivated, setIsActivated] = useState(false);
const handleClick = () => {
setIsActivated(true);
onClick();
setTimeout(() => setIsActivated(false), 300);
};
return (
<button
className={`quantum-btn quantum-btn--${variant} ${isActivated ? 'activated' : ''}`}
onClick={handleClick}
>
{children}
{isActivated && <span className="quantum-ripple"></span>}
</button>
);
};
// Komponent z hookiem useState
const QuantumCounter: React.FC = () => {
const [energy, setEnergy] = useState(0);
const [isCharging, setIsCharging] = useState(false);
const generateEnergy = () => {
setIsCharging(true);
const interval = setInterval(() => {
setEnergy(prev => {
const newEnergy = prev + Math.floor(Math.random() * 10) + 1;
if (newEnergy >= 100) {
clearInterval(interval);
setIsCharging(false);
console.log("Bateria kwantowa w pełni naładowana!");
return 100;
}
return newEnergy;
});
}, 200);
};
const resetEnergy = () => {
setEnergy(0);
setIsCharging(false);
console.log("Bateria kwantowa zresetowana");
};
return (
<div className="quantum-counter">
<h3>Kwantowy generator energii</h3>
<div className="energy-display">
<div className="energy-bar">
<div
className="energy-fill"
style={{ width: `${energy}%` }}
></div>
</div>
<span className="energy-text">{energy}% energii</span>
</div>
<div className="counter-controls">
<QuantumButton
onClick={generateEnergy}
variant="quantum"
disabled={isCharging}
>
{isCharging ? 'Ładowanie...' : 'Generuj energię'}
</QuantumButton>
<QuantumButton
onClick={resetEnergy}
variant="secondary"
>
Resetuj
</QuantumButton>
</div>
{energy === 100 && (
<div className="achievement">
Osiągnięcie odblokowane: Kwantowy Mistrz!
</div>
)}
</div>
);
};
// ===========================================
// 2. Hook useEffect - efekty uboczne
// ===========================================
console.log("=== 2. HOOK USEEFFECT ===");
const QuantumClock: React.FC = () => {
const [currentTime, setCurrentTime] = useState(new Date());
const [quantumTime, setQuantumTime] = useState(0);
// useEffect dla aktualizacji czasu
useEffect(() => {
console.log("Zegar kwantowy włączony");
const timer = setInterval(() => {
setCurrentTime(new Date());
setQuantumTime(prev => prev + 1);
}, 1000);
// Funkcja sprzątająca
return () => {
clearInterval(timer);
console.log("Zegar kwantowy wyłączony");
};
}, []); // Pusta tablica zależności - uruchamia się raz
// useEffect z zależnością
useEffect(() => {
if (quantumTime > 0 && quantumTime % 10 === 0) {
console.log(`Kwantowy punkt kontrolny: ${quantumTime} sekund`);
}
}, [quantumTime]); // Uruchamia się, gdy zmieni się quantumTime
const formatTime = (date: Date) => {
return date.toLocaleTimeString('pl-PL');
};
return (
<div className="quantum-clock">
<h3>Kwantowy portal czasu</h3>
<div className="time-display">
<div className="real-time">
<span className="time-label">Czas ziemski:</span>
<span className="time-value">{formatTime(currentTime)}</span>
</div>
<div className="quantum-time">
<span className="time-label">Czas kwantowy:</span>
<span className="time-value">{quantumTime}s</span>
</div>
</div>
</div>
);
};
// ===========================================
// 3. React a tradycyjny DOM
// ===========================================
console.log("=== 3. REACT A TRADYCYJNY DOM ===");
const DOMComparison: React.FC = () => {
const [items, setItems] = useState<string[]>(['Quantum Core', 'Energy Shield', 'Plasma Drive']);
const [newItem, setNewItem] = useState('');
// Sposób Reacta - deklaratywny
const addItemReact = () => {
if (newItem.trim()) {
setItems(prev => [...prev, newItem.trim()]);
setNewItem('');
console.log(`Sposób Reacta: dodano "${newItem}" do kwantowego ekwipunku`);
}
};
// Tradycyjny sposób z DOM (dla porównania)
const addItemTraditional = () => {
console.log("Tradycyjny sposób z DOM (niezalecany w React):");
console.log(" 1. document.getElementById('list')");
console.log(" 2. createElement('li')");
console.log(" 3. appendChild(listItem)");
console.log(" 4. Ręczne zarządzanie obsługą zdarzeń");
console.log(" 5. Ręczna synchronizacja stanu");
};
return (
<div className="dom-comparison">
<h3>React a tradycyjny DOM</h3>
<div className="react-way">
<h4>Sposób Reacta (deklaratywny)</h4>
<div className="input-group">
<input
type="text"
value={newItem}
onChange={(e) => setNewItem(e.target.value)}
placeholder="Wpisz komponent kwantowy..."
className="quantum-input"
/>
<QuantumButton onClick={addItemReact}>
Dodaj do ekwipunku
</QuantumButton>
</div>
<div className="inventory-list">
<h5>Kwantowy ekwipunek:</h5>
<ul>
{items.map((item, index) => (
<li key={index} className="inventory-item">
{item}
<button
onClick={() => setItems(prev => prev.filter((_, i) => i !== index))}
className="remove-btn"
>
×
</button>
</li>
))}
</ul>
</div>
</div>
<div className="traditional-way">
<h4>Tradycyjny sposób z DOM</h4>
<QuantumButton onClick={addItemTraditional} variant="secondary">
Pokaż tradycyjne podejście
</QuantumButton>
<p className="comparison-note">
React sam aktualizuje DOM dzięki Virtual DOM!
</p>
</div>
</div>
);
};
// ===========================================
// 4. Kompozycja komponentów
// ===========================================
console.log("=== 4. KOMPOZYCJA KOMPONENTÓW ===");
interface QuantumModuleProps {
title: string;
status: 'online' | 'offline' | 'maintenance';
children: React.ReactNode;
}
const QuantumModule: React.FC<QuantumModuleProps> = ({ title, status, children }) => {
const getStatusColor = () => {
switch (status) {
case 'online': return '#4caf50';
case 'offline': return '#f44336';
case 'maintenance': return '#ff9800';
default: return '#999';
}
};
return (
<div className="quantum-module">
<div className="module-header">
<h4>{title}</h4>
<div
className={`status-indicator status-${status}`}
style={{ backgroundColor: getStatusColor() }}
>
{status.toUpperCase()}
</div>
</div>
<div className="module-content">
{children}
</div>
</div>
);
};
const MetropolisControlPanel: React.FC = () => {
const [systemStatus, setSystemStatus] = useState<'online' | 'offline' | 'maintenance'>('online');
const toggleSystem = () => {
setSystemStatus(prev => {
const statuses: Array<'online' | 'offline' | 'maintenance'> = ['online', 'maintenance', 'offline'];
const currentIndex = statuses.indexOf(prev);
const nextStatus = statuses[(currentIndex + 1) % statuses.length];
console.log(`Zmiana statusu systemu: ${prev} → ${nextStatus}`);
return nextStatus;
});
};
return (
<div className="control-panel">
<h3>Panel sterowania Metropolii</h3>
<QuantumModule title="System napędu" status={systemStatus}>
<p>Kwantowe silniki napędowe pracują z optymalną wydajnością</p>
<div className="metric">
<span>Prędkość: </span>
<span className="value">
{systemStatus === 'online' ? '299,792,458 m/s' : 'OFFLINE'}
</span>
</div>
</QuantumModule>
<QuantumModule title="Sieć obronna" status={systemStatus}>
<p>Tarcze energetyczne chroniące metropolię</p>
<div className="metric">
<span>Moc tarczy: </span>
<span className="value">
{systemStatus === 'online' ? '98.7%' : 'OFFLINE'}
</span>
</div>
</QuantumModule>
<QuantumModule title="Centrum komunikacji" status={systemStatus}>
<p>Sieć komunikacji oparta na splątaniu kwantowym</p>
<div className="metric">
<span>Siła sygnału: </span>
<span className="value">
{systemStatus === 'online' ? 'Doskonała' : 'OFFLINE'}
</span>
</div>
</QuantumModule>
<div className="panel-controls">
<QuantumButton onClick={toggleSystem} variant="quantum">
Zmień status systemu
</QuantumButton>
</div>
</div>
);
};
// ===========================================
// 5. Podgląd Next.js
// ===========================================
console.log("=== 5. PODGLĄD NEXT.JS ===");
const NextJSPreview: React.FC = () => {
const [currentFeature, setCurrentFeature] = useState(0);
const nextjsFeatures = [
{
title: "App Router",
description: "Routing oparty na plikach, z layoutami i zagnieżdżonymi ścieżkami",
code: `app/
├── layout.tsx // Główny layout
├── page.tsx // Strona główna
├── dashboard/
│ ├── layout.tsx // Layout panelu
│ └── page.tsx // Strona panelu
└── api/
└── route.ts // Endpoint API`
},
{
title: "Server Components",
description: "Renderowanie komponentów na serwerze dla lepszej wydajności",
code: `// app/quantum/page.tsx
async function QuantumPage() {
// To działa na serwerze!
const data = await fetch('https://api.quantum.com/data');
const quantumData = await data.json();
return <div>{quantumData.energy}</div>;
}`
},
{
title: "Strategie renderowania",
description: "SSR, SSG, ISR - wybierz najlepszą strategię dla swojej aplikacji",
code: `// Generowanie statyczne (SSG)
export async function generateStaticParams() {
return [{ id: '1' }, { id: '2' }];
}
// Renderowanie po stronie serwera (SSR)
async function DynamicPage() {
const data = await fetch(url, { cache: 'no-store' });
return <div>{data}</div>;
}`
},
{
title: "Wbudowane optymalizacje",
description: "Automatyczny podział kodu (code splitting), optymalizacja obrazów i fontów",
code: `import Image from 'next/image';
import { Inter } from 'next/font/google';
const inter = Inter({ subsets: ['latin'] });
export default function Page() {
return (
<div className={inter.className}>
<Image
src="/quantum.jpg"
alt="Quantum City"
width={800}
height={600}
priority
/>
</div>
);
}`
}
];
const nextFeature = () => {
setCurrentFeature(prev => (prev + 1) % nextjsFeatures.length);
};
const prevFeature = () => {
setCurrentFeature(prev => (prev - 1 + nextjsFeatures.length) % nextjsFeatures.length);
};
const feature = nextjsFeatures[currentFeature];
return (
<div className="nextjs-preview">
<h3>Funkcje Next.js 16</h3>
<div className="feature-showcase">
<div className="feature-header">
<h4>{feature.title}</h4>
<p>{feature.description}</p>
</div>
<div className="feature-code">
<pre><code>{feature.code}</code></pre>
</div>
<div className="feature-navigation">
<QuantumButton onClick={prevFeature} variant="secondary">
Poprzednia
</QuantumButton>
<span className="feature-counter">
{currentFeature + 1} / {nextjsFeatures.length}
</span>
<QuantumButton onClick={nextFeature} variant="secondary">
Następna
</QuantumButton>
</div>
</div>
</div>
);
};
// ===========================================
// 6. Główny komponent App
// ===========================================
const App: React.FC = () => {
const [activeSection, setActiveSection] = useState('intro');
useEffect(() => {
console.log("Aplikacja Metropolis Quantum zainicjalizowana");
console.log("Czas poznać React i Next.js!");
}, []);
const sections = {
intro: { title: "Wprowadzenie", component: () => (
<div className="intro-section">
<h2>Witaj w Metropolis Quantum!</h2>
<p>
W futurystycznym mieście Metropolis Quantum, gdzie technologia spotyka się z magią,
poznajemy fundamenty React i Next.js - narzędzi, które pozwalają budować
interaktywne aplikacje webowe nowej generacji.
</p>
<div className="intro-features">
<div className="feature-card">
<h4>React</h4>
<p>Biblioteka do budowania interfejsów użytkownika</p>
</div>
<div className="feature-card">
<h4>Next.js</h4>
<p>Framework React z dodatkowymi możliwościami</p>
</div>
<div className="feature-card">
<h4>TypeScript</h4>
<p>Statyczne typowanie dla większego bezpieczeństwa</p>
</div>
</div>
</div>
)},
components: { title: "Komponenty", component: () => <QuantumCounter /> },
hooks: { title: "Hooki", component: () => <QuantumClock /> },
comparison: { title: "Porównanie DOM", component: () => <DOMComparison /> },
composition: { title: "Kompozycja", component: () => <MetropolisControlPanel /> },
nextjs: { title: "Next.js", component: () => <NextJSPreview /> }
};
return (
<div className="metropolis-app">
<header className="app-header">
<h1>Metropolis Quantum</h1>
<p>Platforma do nauki React i Next.js</p>
</header>
<nav className="app-navigation">
{Object.entries(sections).map(([key, section]) => (
<QuantumButton
key={key}
onClick={() => setActiveSection(key)}
variant={activeSection === key ? 'quantum' : 'secondary'}
>
{section.title}
</QuantumButton>
))}
</nav>
<main className="app-content">
<div className="content-container">
{sections[activeSection as keyof typeof sections].component()}
</div>
</main>
<footer className="app-footer">
<p>Napędzane technologią kwantową • Ucz się React i Next.js</p>
</footer>
</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. W którym roku React został udostępniony publicznie jako open source?
2. React został stworzony przez:
3. Główną zaletą React jest:
Zadania praktyczne w grze
- Edytor kodu
Utwórz komponent funkcyjny HelloWorld, który zwraca nagłówek <h1> z komunikatem powitalnym, np. „Witaj w Metropolis Quantum!”.
- Klikanie w kolejności
Ułóż deklarację komponentu funkcyjnego w React