Kurs JavaScript i React · Moduł 10: Ekosystem i przyszłość React
React Server Components (RSC) - przyszłość React
W tej lekcji6
Panel misji pokazuje posty z bazy danych i przycisk polubienia. W klasycznej aplikacji cały kod komponentów, razem z bibliotekami i logiką zapytań, trafia do przeglądarki, a dane dociągasz dopiero po załadowaniu strony. React Server Components odwracają ten podział: część komponentów wykonuje się wyłącznie na serwerze, ma bezpośredni dostęp do danych i nie dodaje ani bajta do paczki JavaScript. To fundamentalna zmiana w myśleniu o aplikacjach React.
Czym są React Server Components?
Server Component renderuje się na serwerze, podczas budowania albo przy każdym żądaniu. Jego wynikiem nie jest gotowy HTML, tylko RSC Payload, czyli zserializowany opis drzewa UI z miejscami na komponenty klienckie. Cykl żądania wygląda tak: klient prosi o stronę, komponenty serwerowe pobierają dane i tworzą payload, klient buduje z niego drzewo, a na końcu komponenty klienckie są hydratowane, czyli dostają zdarzenia i stan. HTML może dodatkowo powstać przez SSR.
Różnice między RSC a SSR
Klasyczny SSR renderuje całą aplikację do HTML, a potem i tak wysyła cały jej kod do przeglądarki na hydratację. RSC pozwala mieszać komponenty serwerowe i klienckie w jednym drzewie:
// Klasyczny SSR (Pages Router) - dane przychodzą z getServerSideProps
export async function getServerSideProps() {
const posts = await fetchPosts(); // Wykonuje się na serwerze przy każdym żądaniu
return { props: { posts } };
}
export default function TraditionalSSRPage({ posts }) {
const [count, setCount] = useState(0);
// Ten komponent razem ze wszystkimi importami trafia też do przeglądarki
return (
<div>
<PostsList posts={posts} />
<Counter count={count} setCount={setCount} />
</div>
);
}
// React Server Components - mix serwera i klienta
async function ServerComponentPage() {
// Ten kod działa TYLKO na serwerze
const posts = await fetchPosts(); // Bezpośrednie wywołanie bazy danych
const user = await getUser();
return (
<div>
{/* Server Component - renderowany na serwerze */}
<PostsList posts={posts} />
{/* Client Component - interaktywny na kliencie */}
<Counter />
{/* Server Component z danymi z serwera */}
<UserProfile user={user} />
</div>
);
}W klasycznym SSR dane pobiera osobna funkcja getServerSideProps, a komponent strony dostaje je w propsach. Serwer renderuje z nich HTML, ale kod TraditionalSSRPage, PostsList i wszystkich ich bibliotek i tak trafia do przeglądarki, żeby React mógł zhydratować stronę. ServerComponentPage jest asynchroniczna i czeka na dane sama: jej kod zostaje na serwerze, a do przeglądarki trafia tylko interaktywny Counter.
Podstawy Server Components
W Next.js App Router każdy komponent jest domyślnie serwerowy. Dyrektywa 'use client' na samej górze pliku wyznacza granicę: ten moduł i jego importy trafiają do przeglądarki i mogą używać hooków, zdarzeń i stanu:
// ServerComponent.jsx (domyślnie server component)
import { db } from './database';
export default async function PostsList() {
// Bezpośredni dostęp do bazy danych
const posts = await db.posts.findMany({
include: { author: true },
orderBy: { createdAt: 'desc' }
});
return (
<div className="posts-list">
{posts.map(post => (
<article key={post.id}>
<h2>{post.title}</h2>
<p>By {post.author.name}</p>
<p>{post.excerpt}</p>
{/* Client Component dla interakcji */}
<LikeButton postId={post.id} initialLikes={post.likes} />
</article>
))}
</div>
);
}
// LikeButton.jsx (client component)
'use client'; // Dyrektywa oznaczająca client component
import { useState } from 'react';
export default function LikeButton({ postId, initialLikes }) {
const [likes, setLikes] = useState(initialLikes);
const [isLiking, setIsLiking] = useState(false);
const handleLike = async () => {
setIsLiking(true);
try {
const response = await fetch(`/api/posts/${postId}/like`, {
method: 'POST'
});
const data = await response.json();
setLikes(data.likes);
} catch (error) {
console.error('Failed to like post:', error);
} finally {
setIsLiking(false);
}
};
return (
<button
onClick={handleLike}
disabled={isLiking}
className="like-button"
>
{likes} {isLiking && '...'}
</button>
);
}PostsList pyta bazę bezpośrednio, a LikeButton obsługuje kliknięcia przez useState. Komponent serwerowy renderuje kliencki jako dziecko i przekazuje mu serializowalne propsy, jak postId. W projekcie to dwa osobne pliki, bo dyrektywa działa tylko na początku pliku.
Pobieranie danych w Server Components
Server Component może bezpiecznie używać sekretów i zapytań do bazy, bo jego kod nigdy nie trafia do przeglądarki. Funkcja cache z Reacta zapamiętuje wynik w obrębie jednego żądania:
// utils/api.js (server-side only)
import { cache } from 'react';
// Wynik zapamiętany w obrębie jednego żądania
export const getPosts = cache(async () => {
const response = await fetch('https://api.example.com/posts', {
// Server Components mogą bezpiecznie używać sekretów
headers: {
'Authorization': `Bearer ${process.env.API_SECRET}`
}
});
return response.json();
});
export const getUser = cache(async (id) => {
// Bezpośrednie zapytanie do bazy danych
return await db.user.findUnique({
where: { id },
include: { profile: true }
});
});
// components/PostsPage.jsx
import { getPosts, getUser } from '../utils/api';
import { Suspense } from 'react';
export default async function PostsPage({ userId }) {
// Równoległe pobieranie danych
const [posts, user] = await Promise.all([
getPosts(),
getUser(userId)
]);
return (
<main>
<h1>Welcome, {user.name}!</h1>
{/* Zagnieżdżony Server Component z własnym pobieraniem danych */}
<Suspense fallback={<div>Loading posts...</div>}>
<PostsList posts={posts} />
</Suspense>
{/* Client Component dla interakcji */}
<CreatePostForm userId={userId} />
</main>
);
}Promise.all pobiera posty i użytkownika równolegle. cache działa tylko w Server Components i deduplikuje wywołania z tymi samymi argumentami, więc kilka komponentów może wołać getUser(userId) bez dodatkowych zapytań.
Streaming i Suspense
Nie każdy fragment strony ładuje się równie szybko. Suspense z właściwością fallback wyznacza granicę: serwer wysyła najpierw zastępczy szkielet, a gotowe sekcje dosyła strumieniowo:
// components/DashboardPage.jsx
import { Suspense } from 'react';
export default function DashboardPage() {
return (
<div className="dashboard">
<h1>Dashboard</h1>
{/* Szybko ładująca się treść */}
<Suspense fallback={<SkeletonCard />}>
<UserStats />
</Suspense>
{/* Wolniej ładująca się treść */}
<Suspense fallback={<SkeletonChart />}>
<AnalyticsChart />
</Suspense>
{/* Bardzo wolno ładująca się treść */}
<Suspense fallback={<SkeletonTable />}>
<ReportsTable />
</Suspense>
</div>
);
}
// components/UserStats.jsx (Server Component)
async function UserStats() {
// Szybkie zapytanie - cache hit
const stats = await getUserStats();
return (
<div className="stats-grid">
<StatCard title="Total Users" value={stats.totalUsers} />
<StatCard title="Active Today" value={stats.activeToday} />
<StatCard title="Revenue" value={`$${stats.revenue}`} />
</div>
);
}
// components/AnalyticsChart.jsx (Server Component)
async function AnalyticsChart() {
// Średnio długie zapytanie
const chartData = await getAnalyticsData();
return (
<div className="chart-container">
{/* Client Component dla interaktywnego wykresu */}
<InteractiveChart data={chartData} />
</div>
);
}
// components/ReportsTable.jsx (Server Component)
async function ReportsTable() {
// Długie zapytanie - złożone agregacje
const reports = await getComplexReports();
return (
<div className="reports-table">
<table>
<thead>
<tr>
<th>Report</th>
<th>Status</th>
<th>Date</th>
</tr>
</thead>
<tbody>
{reports.map(report => (
<tr key={report.id}>
<td>{report.name}</td>
<td>{report.status}</td>
<td>{report.date}</td>
</tr>
))}
</tbody>
</table>
</div>
);
}Każda sekcja ma własną granicę, więc wolna tabela raportów nie blokuje statystyk. Suspense obsługuje stan ładowania, a błędy łapie Error Boundary, więc razem pokrywają cały cykl operacji asynchronicznej. To ten sam streaming, który poznałeś w lekcji o Streaming SSR.
Kompozycja Server i Client Components
Oto wzorce kompozycji, które działają, i jeden, który zawodzi:
// patterns/CompositionPatterns.jsx
// DOBRE - Server Component może renderować Client Component
async function ServerParent() {
const data = await fetchData();
return (
<div>
<h1>Server Rendered Title</h1>
<ClientChild data={data} />
</div>
);
}
// DOBRE - Client Component może renderować Server Component przez children
'use client';
function ClientWrapper({ children }) {
const [isOpen, setIsOpen] = useState(false);
return (
<div>
<button onClick={() => setIsOpen(!isOpen)}>
Toggle Content
</button>
{isOpen && children}
</div>
);
}
// Użycie:
function ParentPage() {
return (
<ClientWrapper>
<ServerContent /> {/* Server Component jako children */}
</ClientWrapper>
);
}
// ZŁE - Client Component nie może bezpośrednio importować Server Component
'use client';
function BadClientComponent() {
const [show, setShow] = useState(false);
return (
<div>
{show && <ServerContent />} {/* To nie zadziała! */}
</div>
);
}
// DOBRE - Server Component przekazany jako prop z JSX (slot)
'use client';
function GoodClientComponent({ content }) {
const [show, setShow] = useState(false);
return (
<div>
<button onClick={() => setShow(!show)}>Toggle</button>
{show && content}
</div>
);
}
// Użycie:
function ParentComponent() {
return (
<GoodClientComponent
content={<ServerContent />}
/>
);
}Zalecany wzorzec to Server Component renderujący Client Component jako dziecko. Gdy kliencki ma zawierać serwerowy, przekaż go jako children albo prop z JSX. Funkcji, na przykład render propa, z serwera do klienta nie wyślesz, bo nie da się jej zserializować, a import serwerowego komponentu w pliku z 'use client' zamieni go w kliencki.
Zaawansowane wzorce
Mutacje przez Server Functions
Do zmiany danych służą Server Functions z dyrektywą 'use server', w formularzach nazywane Server Actions. Formularz wywołuje je bez pisania własnego endpointu:
// actions/postActions.js
'use server'; // Server Actions
import { revalidatePath } from 'next/cache';
export async function createPost(prevState, formData) {
const title = formData.get('title');
const content = formData.get('content');
// Walidacja po stronie serwera
if (!title || !content) {
return { error: 'Title and content are required' };
}
try {
const post = await db.post.create({
data: { title, content, userId: getCurrentUserId() }
});
// Odśwież cache strony z postami
revalidatePath('/posts');
return { success: true, post };
} catch (error) {
return { error: 'Failed to create post' };
}
}
export async function deletePost(postId) {
try {
await db.post.delete({
where: { id: postId }
});
revalidatePath('/posts');
return { success: true };
} catch (error) {
return { error: 'Failed to delete post' };
}
}
// components/CreatePostForm.jsx
'use client';
import { createPost } from '../actions/postActions';
import { useActionState } from 'react';
import { useFormStatus } from 'react-dom';
function SubmitButton() {
const { pending } = useFormStatus();
return (
<button type="submit" disabled={pending}>
{pending ? 'Creating...' : 'Create Post'}
</button>
);
}
export default function CreatePostForm() {
const [state, formAction] = useActionState(createPost, null);
return (
<form action={formAction}>
<div>
<label htmlFor="title">Title:</label>
<input
type="text"
id="title"
name="title"
required
/>
</div>
<div>
<label htmlFor="content">Content:</label>
<textarea
id="content"
name="content"
required
/>
</div>
{state?.error && (
<div className="error">{state.error}</div>
)}
{state?.success && (
<div className="success">Post created successfully!</div>
)}
<SubmitButton />
</form>
);
}useActionState przekazuje akcji poprzedni stan jako pierwszy argument, a dane formularza jako drugi, dlatego createPost przyjmuje prevState, formData. useFormStatus blokuje przycisk na czas wysyłki, a revalidatePath('/posts') odświeża listę. Walidacja w akcji jest obowiązkowa, bo akcja to publiczny endpoint.
Strategie cache
cache z Reacta działa tylko w obrębie jednego żądania. Żeby zapamiętać wynik kosztownego zapytania między żądaniami, Next.js 16 ma dyrektywę 'use cache', którą włączasz opcją cacheComponents: true w next.config.js. Czas życia wpisu ustawia cacheLife, a cacheTag nadaje mu etykietę do unieważniania:
// lib/posts.js
import { cacheLife, cacheTag } from 'next/cache';
export async function getCachedPosts() {
'use cache';
cacheLife('minutes'); // Odświeżanie w tle mniej więcej co minutę
cacheTag('posts');
return db.post.findMany({
include: { author: true },
orderBy: { createdAt: 'desc' },
});
}
export async function getCachedUser(userId) {
'use cache';
cacheLife('hours');
cacheTag('users');
// userId staje się częścią klucza cache
return db.user.findUnique({
where: { id: userId },
include: { profile: true },
});
}
// components/PostsWithCache.jsx
import { getCachedPosts } from '../lib/posts';
export default async function PostsWithCache() {
const posts = await getCachedPosts();
return (
<div>
<h1>Posty z cache</h1>
{posts.map(post => (
<article key={post.id}>
<h2>{post.title}</h2>
<p>Autor: {post.author.name}</p>
</article>
))}
</div>
);
}
// actions/cacheActions.js
'use server';
import { revalidateTag, updateTag } from 'next/cache';
export async function refreshPosts() {
revalidateTag('posts', 'max'); // Stare dane zostają, świeże dociągną się w tle
}
export async function publishPost(formData) {
await db.post.create({ data: { title: formData.get('title') } });
updateTag('posts'); // Autor od razu zobaczy swój wpis
}Argumenty funkcji, jak userId, automatycznie trafiają do klucza cache, więc każdy użytkownik ma osobny wpis. revalidateTag('posts', 'max') oznacza dane jako nieaktualne i odświeża je w tle przy następnym żądaniu, a updateTag, dostępne tylko w Server Actions, wygasza je od razu, żeby autor zobaczył swoją zmianę. Starsze unstable_cache zostało w Next.js 16 zastąpione przez 'use cache', a jednoargumentowe revalidateTag jest przestarzałe.
Performance i optymalizacje
Największego zysku z RSC nie widać w kodzie: komponenty serwerowe i ich importy nie trafiają do paczki klienta:
// Server Components nie trafiają do paczki klienta!
// ServerHeavyComponent.jsx (Server Component)
import { someHeavyLibrary } from 'heavy-library'; // Nie trafi do paczki klienta!
import { complexCalculation } from './utils/complex';
export default async function ServerHeavyComponent() {
const data = await fetchData();
const processed = complexCalculation(data); // Dzieje się na serwerze
const result = someHeavyLibrary.process(processed);
return (
<div>
<h2>Processed Data</h2>
<pre>{JSON.stringify(result, null, 2)}</pre>
</div>
);
}
// ClientLightComponent.jsx (Client Component)
'use client';
import { useState } from 'react';
export default function ClientLightComponent({ serverData }) {
const [selected, setSelected] = useState(null);
return (
<div>
{serverData.map(item => (
<button
key={item.id}
onClick={() => setSelected(item)}
className={selected?.id === item.id ? 'selected' : ''}
>
{item.name}
</button>
))}
{selected && <ItemDetails item={selected} />}
</div>
);
}heavy-library działa tylko na serwerze, więc użytkownik jej nie pobiera. Do przeglądarki trafia wyłącznie lekki ClientLightComponent.
Error Boundaries dla Server Components
Błąd w komponencie serwerowym trafia do najbliższej granicy błędu po stronie klienta. Error Boundary musi być klasą, więc plik zaczyna się od 'use client':
// components/ServerErrorBoundary.jsx
'use client';
import { Component } from 'react';
export class ServerErrorBoundary extends Component {
constructor(props) {
super(props);
this.state = { hasError: false, error: null };
}
static getDerivedStateFromError(error) {
return { hasError: true, error };
}
componentDidCatch(error, errorInfo) {
console.error('Server component error:', error, errorInfo);
// Wyślij do serwisu monitorującego
}
render() {
if (this.state.hasError) {
return (
<div className="error-boundary">
<h2>Something went wrong on the server</h2>
<details>
<summary>Error details</summary>
<pre>{this.state.error?.message}</pre>
</details>
<button
onClick={() => this.setState({ hasError: false })}
>
Try again
</button>
</div>
);
}
return this.props.children;
}
}
// Użycie w layoucie
export default function Layout({ children }) {
return (
<html>
<body>
<ServerErrorBoundary>
{children}
</ServerErrorBoundary>
</body>
</html>
);
}getDerivedStateFromError przełącza widok na ekran awaryjny, a componentDidCatch raportuje błąd. W produkcji Next.js ukrywa treść błędów z serwera, więc zobaczysz ogólny komunikat, a szczegóły znajdziesz w logach. W Next.js nie musisz pisać tej klasy sam: plik error.js tworzy granicę błędu dla całego segmentu trasy, a od wersji 16.3 funkcja catchError z next/error zbuduje ją z komponentu funkcyjnego i przekaże mu retry(), które ponownie renderuje także komponenty serwerowe.
Pierwszym frameworkiem, który w pełni zintegrował RSC, był Next.js z App Routerem. Polecam zaczynać każdy komponent jako serwerowy i dodawać 'use client' dopiero tam, gdzie potrzebujesz stanu lub zdarzeń. RSC dają lepszą wydajność, automatyczny podział kodu i bezpieczniejsze operacje na serwerze, a w lekcji o Partial Pre-rendering połączysz je ze statyczną powłoką strony.
Pamiętaj: Server Components to załoga stacji naziemnej - przygotowuje dane i wysyła gotowy plan, a na pokład trafiają tylko moduły, którymi ktoś naprawdę steruje. W przykładzie poniżej przycisk "Pokaż, co trafia do przeglądarki" oznacza, który kod zostaje na serwerze, a który działa w przeglądarce.
Kod do tej lekcji: App.jsx
import { Suspense, use, useState } from 'react';
// === React Server Components - symulacja w przeglądarce ===
// Prawdziwy Server Component to asynchroniczna funkcja wykonywana na serwerze:
// async function PostsList() { const posts = await db.post.findMany(); ... }
// Przeglądarka nie uruchomi takiego kodu, więc "serwer" udajemy obietnicą
// odczytywaną przez use(), a czekanie na dane obsługuje Suspense, tak jak przy
// strumieniowaniu RSC Payload.
const database = {
stats: { posts: 156, crew: 89, online: 23 },
posts: [
{ id: 1, title: 'Odkrycie nowej galaktyki', author: 'Komandor Nova', likes: 42 },
{ id: 2, title: 'Technologie napędów kosmicznych', author: 'Astro', likes: 28 },
{ id: 3, title: 'Życie na Marsie - raport', author: 'Ra', likes: 56 },
],
};
const serverCache = new Map();
// "Zapytanie do bazy" - ta sama obietnica dla tej samej tabeli
function queryServer(table, delay) {
if (!serverCache.has(table)) {
serverCache.set(table, new Promise(resolve => setTimeout(() => resolve(database[table]), delay)));
}
return serverCache.get(table);
}
function Tag({ type, show }) {
if (!show) return null;
const server = type === 'server';
return (
<span style={{ ...styles.tag, ...(server ? styles.serverTag : styles.clientTag) }}>
{server ? 'Server Component: 0 KB kodu w paczce JS' : "Client Component ('use client'): kod w paczce JS"}
</span>
);
}
// SERVER COMPONENT (symulacja): bez stanu i zdarzeń, tylko dane i JSX
function ServerStats({ showBundle }) {
const stats = use(queryServer('stats', 600));
return (
<section style={{ ...styles.box, ...(showBundle ? styles.serverBox : null) }}>
<Tag type="server" show={showBundle} />
<div style={styles.statsGrid}>
<div style={styles.stat}><strong style={styles.statValue}>{stats.posts}</strong>Posty</div>
<div style={styles.stat}><strong style={styles.statValue}>{stats.crew}</strong>Członkowie załogi</div>
<div style={styles.stat}><strong style={styles.statValue}>{stats.online}</strong>Online</div>
</div>
</section>
);
}
// SERVER COMPONENT (symulacja): renderuje komponent kliencki jako dziecko
// i przekazuje mu tylko serializowalne propsy (liczba polubień)
function ServerPostsList({ showBundle }) {
const posts = use(queryServer('posts', 1200));
return (
<section style={{ ...styles.box, ...(showBundle ? styles.serverBox : null) }}>
<Tag type="server" show={showBundle} />
{posts.map(post => (
<article key={post.id} style={styles.post}>
<h3 style={styles.postTitle}>{post.title}</h3>
<div style={styles.postMeta}>
<span>Autor: {post.author}</span>
<LikeButton initialLikes={post.likes} showBundle={showBundle} />
</div>
</article>
))}
</section>
);
}
// CLIENT COMPONENT: w projekcie osobny plik zaczynający się od 'use client'.
// Tylko taki kod trafia do przeglądarki i może używać stanu oraz zdarzeń.
function LikeButton({ initialLikes, showBundle }) {
const [liked, setLiked] = useState(false);
const likes = initialLikes + (liked ? 1 : 0);
return (
<span style={showBundle ? styles.clientBox : null}>
<Tag type="client" show={showBundle} />
<button onClick={() => setLiked(l => !l)} style={{ ...styles.like, color: liked ? '#ff6b6b' : '#8892b0' }}>
{liked ? 'Polubione' : 'Lubię to'} ({likes})
</button>
</span>
);
}
export default function App() {
const [showBundle, setShowBundle] = useState(false);
return (
<div style={styles.page}>
<div style={{ maxWidth: '700px', margin: '0 auto' }}>
<h1 style={styles.title}>React Server Components - symulacja</h1>
<p style={styles.subtitle}>
Komponenty serwerowe pobierają dane, a w przeglądarce działa tylko interaktywny przycisk polubienia
</p>
<button onClick={() => setShowBundle(s => !s)} style={styles.toggle}>
{showBundle ? 'Ukryj podział na serwer i klienta' : 'Pokaż, co trafia do przeglądarki'}
</button>
<Suspense fallback={<p style={styles.fallback}>Serwer liczy statystyki...</p>}>
<ServerStats showBundle={showBundle} />
</Suspense>
<h2 style={styles.h2}>Posty z bazy (Server Component + kliencki LikeButton)</h2>
<Suspense fallback={<p style={styles.fallback}>Serwer pobiera posty z bazy...</p>}>
<ServerPostsList showBundle={showBundle} />
</Suspense>
</div>
</div>
);
}
const styles = {
page: { minHeight: '100vh', background: 'linear-gradient(135deg, #0a0e27 0%, #1a1a3e 100%)', padding: '24px', color: '#e0e1dd', fontFamily: 'system-ui, sans-serif' },
title: { textAlign: 'center', color: '#00d4ff', margin: '0 0 6px', fontSize: '22px' },
subtitle: { textAlign: 'center', color: '#8892b0', margin: '0 0 14px', fontSize: '13px' },
toggle: { display: 'block', margin: '0 auto 16px', padding: '6px 14px', background: 'rgba(0,212,255,0.15)', color: '#00d4ff', border: '1px solid rgba(0,212,255,0.4)', borderRadius: '6px', cursor: 'pointer' },
fallback: { color: '#8892b0', padding: '16px', border: '1px dashed rgba(0,212,255,0.25)', borderRadius: '8px' },
box: { borderRadius: '10px', padding: '10px', marginBottom: '16px', border: '1px solid transparent' },
serverBox: { border: '1px dashed #ffa500', background: 'rgba(255,165,0,0.05)' },
clientBox: { display: 'inline-flex', flexDirection: 'column', alignItems: 'flex-end', gap: '2px', padding: '4px', border: '1px solid #00ff88', borderRadius: '6px' },
tag: { display: 'inline-block', fontSize: '10px', padding: '2px 6px', borderRadius: '4px', marginBottom: '6px' },
serverTag: { background: 'rgba(255,165,0,0.15)', color: '#ffa500' },
clientTag: { background: 'rgba(0,255,136,0.15)', color: '#00ff88', marginBottom: 0 },
statsGrid: { display: 'grid', gridTemplateColumns: 'repeat(3, 1fr)', gap: '10px' },
stat: { padding: '12px', background: 'rgba(0,212,255,0.08)', borderRadius: '8px', textAlign: 'center', fontSize: '12px', color: '#8892b0' },
statValue: { display: 'block', fontSize: '24px', color: '#00d4ff' },
h2: { color: '#64ffda', fontSize: '16px', margin: '0 0 8px' },
post: { padding: '10px 12px', margin: '6px 0', background: 'rgba(0,0,0,0.3)', borderRadius: '8px', border: '1px solid rgba(0,212,255,0.15)' },
postTitle: { color: '#00d4ff', margin: '0 0 6px', fontSize: '15px' },
postMeta: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', fontSize: '12px', color: '#8892b0', gap: '8px' },
like: { background: 'none', border: 'none', cursor: 'pointer', fontSize: '12px' },
};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 dyrektywa 'use client' na początku pliku komponentu?
2. Jaka jest kluczowa różnica między React Server Components a tradycyjnym SSR?
To 2 z 5 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Klikanie w kolejności
Ułóż składnię Suspense boundary z komponentem fallback:
- Edytor kodu
Pokaż dane gwiazdozbioru z obserwatorium przez Suspense i use() z React 19. ___BLANK1___: getConstellation zapisuje w cache obietnicę z fetchConstellation(name), żeby każda nazwa była pobierana tylko raz. ___BLANK2___: ConstellationCard odczytuje dane przez use() z obietnicy zwróconej przez getConstellation(name) (nie twórz nowej obietnicy w renderze). ___BLANK3___: fallback granicy Suspense to element z tekstem o ładowaniu, np. <p>Ładowanie danych z teleskopu...</p>. Po kliknięciu innego gwiazdozbioru przez chwilę zobaczysz fallback, a po powrocie do już pobranego dane pojawią się od razu.
- Układanie w pionie
Uporządkuj etapy Streaming SSR w React (od wersji 18):
- Edytor kodu
Dokończ klasę MissionBoundary, granicę błędów dla paneli mostka. Czujnik paliwa jest uszkodzony i jego panel rzuca błąd, a pozostałe panele mają działać dalej. ___BLANK1___: getDerivedStateFromError zwraca nowy stan z polem error, w którym zapisujesz złapany błąd ({ error }). ___BLANK2___: componentDidCatch zgłasza awarię funkcją reportCrash(error, info.componentStack). ___BLANK3___: gdy w stanie jest błąd, render zwraca widok z this.props.renderFallback, któremu przekazujesz błąd ze stanu i funkcję this.reset (klasa zostaje bez JSX). Kliknięcie Restartuj czujnik naprawia czujnik i resetuje granicę, więc panel paliwa wraca z wartością 50%.
- Układanie w poziomie
Ułóż składnię opakowywania komponentu w Error Boundary z fallback:
- Układanie w pionie
Uporządkuj cykl życia żądania w architekturze React Server Components:
- Klikanie w kolejności
Uporządkuj implementację Server Component:
- Edytor kodu
Uzupełnij przyciski biblioteki komponentów Floty. ___BLANK1___: przycisk jest wyłączony, gdy ma prop disabled albo trwa ładowanie (loading). ___BLANK2___: padding pochodzi z tokenów: tokens.spacing dla wybranego rozmiaru size (sm, md albo lg). ___BLANK3___: IconButton pokazuje tylko ikonę, więc przekaż do Button atrybut aria-label z wartością label, żeby czytnik ekranu ogłosił nazwę przycisku. Komponenty nie mają stanu ani efektów, więc nadają się także do Server Components.
Zadania po tej lekcji
- PytanieDyrektywa 'use client'
- Kliknij w kolejnościSkładnia Suspense z fallback
- PytanieServer Components vs SSR
- PytanieKompozycja Server i Client Components
- Zadanie z kodemPraktyka: Suspense do pobierania danych
- PytanieError Boundary a Suspense
- Ułóż w kolejnościPipeline Streaming SSR
- Zadanie z kodemPraktyka: Granice błędów
- Ułóż w kolejnościSkładnia Error Boundary z fallback
- Ułóż w kolejnościCykl życia żądania z React Server Components
- Kliknij w kolejnościImplementacja Server Components
- PytanieAdopcja React Server Components
- Zadanie z kodemPraktyka: Biblioteka komponentów