Kurs Next.js · Moduł 1: Konfiguracja Next.js

Wprowadzenie do React i Next.js - historia, zalety, ekosystem

6 min czytania ·
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:

  1. Renderowanie hybrydowe - możliwość renderowania zarówno po stronie serwera (SSR), statycznie (SSG), jak i po stronie klienta

  2. Routing oparty na systemie plików - tworzenie ścieżek aplikacji poprzez strukturę folderów

  3. Automatyczny code splitting - dzielenie kodu na mniejsze części, ładowane tylko wtedy, gdy są potrzebne

  4. Optymalizacja obrazów - automatyczne przetwarzanie i serwowanie obrazów w optymalnych formatach

  5. Zero-config - działa natychmiast po instalacji, z minimalną konfiguracją

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

  1. Wydajność - optymalizacje takie jak code splitting, wstępne ładowanie, optymalizacja obrazów

  2. Skalowalność - architektura oparta na komponentach ułatwia zarządzanie dużymi aplikacjami

  3. Doświadczenie dewelopera - szybka pętla zwrotna dzięki hot reloadingowi, jasna struktura projektu

  4. SEO - renderowanie po stronie serwera i generowanie statyczne poprawiają indeksowanie przez wyszukiwarki

  5. Ekosystem - bogaty wybór bibliotek i narzędzi

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

W 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. 1. W którym roku React został udostępniony publicznie jako open source?

  2. 2. React został stworzony przez:

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

  1. PytanieRok udostępnienia Reacta
  2. PytanieTwórca Reacta
  3. Zadanie z kodemPraktyka: Komponent HelloWorld
  4. PytanieGłówna zaleta Reacta
  5. Kliknij w kolejnościDeklaracja komponentu funkcyjnego

Przydatne artykuły