Kurs vibe coding z Claude Code · Moduł 3: Klon Twittera
Dziennik pokładowy: stan, polubienia i nowy wpis
W tej lekcji8
Komunikator wygląda jak prawdziwy ale nic w nim nie reaguje. Przycisk polubień stoi bez ruchu, a nowego wpisu nie da się dodać. Najprostszy pomysł, zwykła zmienna w komponencie, nie zadziała:
function LikeButton() {
let likes = 0;
return (
<button onClick={() => { likes++; console.log(likes); }}>
Polub ({likes})
</button>
);
}Konsola pokaże 1, 2, 3, ale na ekranie zostanie 0. React nie wie, że zmienna się zmieniła, więc nie rysuje komponentu od nowa. A gdyby narysował, likes znów zaczęłoby od zera, bo przy każdym renderze funkcja komponentu wykonuje się od początku. Potrzebna jest pamięć, która przetrwa między renderami, i sygnał "dane się zmieniły, odśwież ekran".
useState w jednej linii
Oba daje useState, hook Reacta. Hook to funkcja z przedrostkiem use, którą wywołujesz na najwyższym poziomie komponentu, nie w warunku ani pętli. Pomyśl o dzienniku pokładowym: kapitan zapisuje w nim stan okrętu, a każdy nowy wpis to znak dla załogi, że coś się zmieniło. Cała deklaracja mieści się w jednej linii:
const [count, setCount] = useState(0);useState(0) tworzy stan z wartością początkową 0 i zwraca tablicę z dwoma elementami: count to aktualna wartość, a setCount to setter, funkcja do jej zmiany. Wywołanie setCount(count + 1) zapisuje nową wartość i każe Reactowi narysować komponent jeszcze raz. Setter nie zmienia zmiennej od razu: w bieżącym wywołaniu count ma starą wartość, a nowa pojawi się w następnym renderze. Stan działa w przeglądarce, więc plik z nim zaczyna się od "use client" z lekcji 2_2.
Polecenie dla Claude Code
Funkcja dotyka czterech plików i zostawia wybory, na przykład gdzie trzymać wpisy i jak je zapisać, więc zaczynasz od planu, jak w lekcji 2_1.
Polecenie dla Claude Code:
/plan Ożyw oś komunikatora. 1) Przycisk polubień jako osobny Client
Component w components/LikeButton.tsx; liczba startuje z propsa likes
z @components/Post.tsx. 2) Nad wpisami z @lib/posts.ts formularz nowego
wpisu z polem textarea; nowy wpis kapitana ląduje na górze, z godziną
dodania. 3) Nowe wpisy zapisują się w localStorage i wracają po
odświeżeniu. "use client" tylko w plikach ze stanem, Post zostaje bez
dyrektywy. Po każdym kroku npm run build i npm run lint.Plan powinien wymienić nowe pliki components/LikeButton.tsx i components/Feed.tsx oraz zmiany w components/Post.tsx i app/feed/page.tsx. Zaakceptuj go przez Yes, manually approve edits i czytaj każdą edycję.
Co napisał Claude: przycisk polubień
Otwórz components/LikeButton.tsx. To cały plik:
"use client";
import { useState } from "react";
interface LikeButtonProps {
initialLikes: number;
}
export default function LikeButton({ initialLikes }: LikeButtonProps) {
const [likes, setLikes] = useState(initialLikes);
return (
<button
type="button"
onClick={() => setLikes(likes + 1)}
className="mt-3 text-sm text-gray-500 hover:text-red-600"
>
Polub ({likes})
</button>
);
}onClick reaguje na kliknięcie, a setter podbija liczbę. Prop initialLikes się nie zmienia: daje tylko wartość początkową, a dalej żyje stan likes. W Post.tsx stary przycisk zastąpiła linia <LikeButton initialLikes={likes} />, a sam Post nadal nie ma dyrektywy. Do przeglądarki trafia więc tylko kod przycisku, jak radziła lekcja 2_2.
Co napisał Claude: oś z formularzem
Otwórz components/Feed.tsx. Na górze pliku Claude opisał wpis z formularza i funkcję, która czyta zapisane wpisy:
interface CrewPost {
id: string;
content: string;
createdAt: string;
}
const STORAGE_KEY = "kraken-posts";
function loadPosts(): CrewPost[] {
const saved = localStorage.getItem(STORAGE_KEY);
return saved ? JSON.parse(saved) : [];
}localStorage to mały magazyn w przeglądarce, który trzyma teksty pod kluczami. Tablicę zamieniasz na tekst przez JSON.stringify, a z powrotem przez JSON.parse. Zwróć uwagę na createdAt: string: godzina dodania jest tekstem w formacie ISO, na przykład 2026-11-14T09:30:00.000Z. Dlaczego nie Date, wyjaśni przegląd kapitana.
Komponent zaczyna się od jednej osłony i dwóch stanów:
use(browser("Wpisy z formularza są zapisane w localStorage."));
const [posts, setPosts] = useState<CrewPost[]>(loadPosts);
const [draft, setDraft] = useState("");posts to tablica wpisów, a draft to treść pola. Na górze pliku stoją importy use, useEffect i useState z react oraz browser z react-dom. Zamiast wartości początkowej useState dostał funkcję loadPosts: React wywoła ją raz, przy pierwszym renderze, więc zapisane wpisy są na miejscu, zanim cokolwiek pojawi się na ekranie. Pierwsza linia to nowość z React 19.3: use(browser(...)) mówi "ten komponent rysuj tylko w przeglądarce". Next.js renderuje Client Components także na serwerze przy buildzie, a tam localStorage nie istnieje. Bez tej linii build kończy się błędem ReferenceError: localStorage is not defined. Jeśli Claude nie zna tego wzorca, poproś, żeby zajrzał do dokumentacji w node_modules/next/dist/docs/, tak jak każe mu AGENTS.md.
Formularz i nowy wpis na górze
Pole formularza Claude podpiął do stanu draft. W skrócie, bez klas Tailwinda, wygląda tak:
<form onSubmit={handleSubmit}>
<textarea value={draft} onChange={(e) => setDraft(e.target.value)} rows={3} />
<button type="submit">Wyślij</button>
</form>To formularz kontrolowany: pole pokazuje wartość ze stanu (value), a onChange zapisuje każdą zmianę przez e.target.value. Dzięki temu w każdej chwili wiesz, co jest w polu, i wyczyścisz je jednym setterem. Wysłanie obsługuje funkcja handleSubmit:
const handleSubmit = (e: React.SubmitEvent<HTMLFormElement>) => {
e.preventDefault();
if (!draft.trim()) return;
const newPost: CrewPost = {
id: String(Date.now()),
content: draft.trim(),
createdAt: new Date().toISOString(),
};
setPosts([newPost, ...posts]);
setDraft("");
};Po zatwierdzeniu formularza przeglądarka domyślnie przeładowuje stronę, a wtedy cały stan przepada; e.preventDefault() to blokuje. Typ React.SubmitEvent<HTMLFormElement> opisuje właśnie to zdarzenie wysłania formularza. trim() obcina spacje, więc pusty wpis się nie wyśle. setPosts([newPost, ...posts]) tworzy nową tablicę: nowy wpis na początku, a ...posts, czyli operator spread, kopiuje za nim stare elementy. Stara tablica zostaje nietknięta, a React dostaje nową i wie, że trzeba odświeżyć ekran. Każdy wpis Claude wyświetla komponentem Post, który dostał opcjonalny prop time z wartością new Date(post.createdAt).toLocaleTimeString("pl-PL"): tekst zamienia się w datę dopiero przy wyświetlaniu.
Efekt: zapis po każdej zmianie
Zostało zapisywanie. Odpowiada za nie jeden efekt:
useEffect(() => {
localStorage.setItem(STORAGE_KEY, JSON.stringify(posts));
}, [posts]);Zapis do localStorage to efekt uboczny: coś, co komponent robi poza rysowaniem ekranu. Do tego służy useEffect. React uruchamia efekt po renderze, a drugi argument, tablica zależności, mówi kiedy. [posts] znaczy "po pierwszym renderze i po każdym, w którym zmieniła się tablica posts", pusta tablica [] uruchamia efekt raz, po pierwszym renderze, czyli przy montowaniu komponentu, a brak tablicy po każdym renderze. W trybie deweloperskim App Router włącza Strict Mode, który uruchamia każdy efekt jeden dodatkowy raz, żeby wyłapać błędy; podwójny zapis tych samych wpisów niczego nie psuje.
W app/feed/page.tsx Claude owinął <Feed /> w <Suspense fallback={<p>Wczytuję Twoje wpisy...</p>}>. Przy buildzie serwer zostawia tam tekst z fallback, a przeglądarka podmienia go na formularz i wpisy. Bez tej osłony build też się przerwie. Strona osi zostaje Server Component: wpisy z lib/posts.ts przychodzą z serwera, a w przeglądarce działa tylko Feed. Wpisy z formularza nie mają linku "Otwórz wpis", bo żyją tylko w Twojej przeglądarce i serwer ich nie zna.
Przegląd kapitana
Dodaj dwa wpisy, kliknij kilka polubień, odśwież stronę i sprawdź:
- Godzina po odświeżeniu. Typowy błąd agenta to
createdAt: Datew interfejsie inew Date()przy tworzeniu wpisu. Przed odświeżeniem wszystko działa, a po nim Next.js pokazuje taki błąd:
Runtime TypeError
post.createdAt.toLocaleTimeString is not a functionJSON.stringify zamienił datę na tekst, a JSON.parse nie zamienia go z powrotem, więc w stanie leży napis, nie Date. TypeScript tego nie wyłapie, bo JSON.parse zwraca typ any, któremu kompilator wierzy na słowo: build i lint przejdą. Poprawka to tekst ISO w interfejsie i new Date(...) dopiero przy wyświetlaniu, jak w kodzie powyżej. W diffie szukaj słowa Date w typach danych, które trafiają do localStorage.
- Kopia, nie mutacja. W kodzie nie ma
posts.push(newPost)anipost.likes++.pushzmienia istniejącą tablicę i nie wywołuje settera, a nawetsetPosts(posts)po nim nic nie da, bo React dostaje tę samą tablicę i uznaje, że nic się nie zmieniło. - Stan we właściwym komponencie. Liczba polubień jest potrzebna tylko przyciskowi, więc mieszka w
LikeButton. Wpisy potrzebują i formularz, i lista, więc mieszkają w ich wspólnym rodzicu,Feed. Częsta pomyłka: Claude dzieliFeednaCreatePostFormiPostList, każdy z własnymuseStatewpisów, i formularz dodaje do tablicy, której lista nie widzi. Lekarstwo nazywa się lifting state up: stan idzie w górę, do rodzica:
<CreatePostForm onAdd={(newPost) => setPosts([newPost, ...posts])} />
<PostList posts={posts} />Dane płyną w dół jako propsy, a zmiany w górę przez funkcję: formularz nie zmienia stanu sam, tylko woła onAdd, a rodzic aktualizuje tablicę i oba dzieci dostają tę samą.
- Lint bez wyciszania. Jeśli Claude wczytuje wpisy w
useEffectprzezsetPosts,npm run lintzgłosi regułęreact-hooks/set-state-in-effect. Nie zgadzaj się na komentarzeslint-disable, tylko poproś o wczytanie wuseState(loadPosts).
Następny krok
Gdy lista przejdzie, poproś o commit z opisem w rodzaju "Oś: polubienia, formularz wpisu i zapis w localStorage". Jeśli Claude przy okazji przepisał pół osi, /rewind z opcją Restore code wraca do stanu sprzed polecenia. Potem małe rozszerzenie:
Dodaj pod polem w @components/Feed.tsx licznik znaków w rodzaju "12/280".
Limit 280 znaków, licznik czerwony powyżej 90% limitu, przycisk Wyślij
wyłączony dla pustego i za długiego wpisu. Nic więcej nie zmieniaj.Licznik nie potrzebuje nowego stanu, bo liczbę znaków da się policzyć z draft.length przy każdym renderze. Jeśli Claude doda osobny useState na licznik, zapytaj, po co. W edytorze poniżej czeka oś do klikania: polub wpis, dodaj nowy i kliknij "Wczytaj ponownie", żeby zobaczyć, że godzina przetrwała zapis jako tekst.
Pamiętaj: stan to dziennik pokładowy komponentu, a datę zabierasz na ląd jako tekst i zamieniasz w kalendarz dopiero przy czytaniu.
Kod do tej lekcji: App.jsx
// Oś komunikatora: polubienia, formularz nowego wpisu i zapis w localStorage.
// W Next.js ten komponent rysujesz tylko w przeglądarce: use(browser()) i <Suspense>.
// Tutaj nie ma serwera, więc localStorage jest dostępny od razu.
import { useEffect, useState } from 'react';
import Post from './components/Post';
const STORAGE_KEY = 'kraken-posts';
// Wpisy załogi, które w projekcie leżą w lib/posts.ts
const crewPosts = [
{ id: '1', author: 'Anne Bonny', avatar: 'AB', content: 'Kraken widziany przy Wyspie Czaszek. Płyniemy na zachód.', likes: 12 },
{ id: '2', author: 'Jack Rackham', avatar: 'JR', content: 'Ster naprawiony. Kto pomoże przy żaglach?', likes: 5 },
];
function loadPosts() {
const saved = localStorage.getItem(STORAGE_KEY);
return saved ? JSON.parse(saved) : [];
}
export default function App() {
// Leniwy start: loadPosts działa raz, przy pierwszym renderze
const [posts, setPosts] = useState(loadPosts);
const [draft, setDraft] = useState('');
// Zapis po pierwszym renderze i po każdej zmianie posts
useEffect(() => {
localStorage.setItem(STORAGE_KEY, JSON.stringify(posts));
}, [posts]);
const handleSubmit = (e) => {
e.preventDefault();
if (!draft.trim()) return;
const newPost = {
id: String(Date.now()),
content: draft.trim(),
createdAt: new Date().toISOString(), // tekst ISO, a nie obiekt Date
};
setPosts([newPost, ...posts]); // nowa tablica, nowy wpis na górze
setDraft('');
};
// Udaje odświeżenie strony: wpisy wracają z localStorage przez JSON.parse
const reload = () => setPosts(loadPosts());
return (
<div className="min-h-screen bg-gray-50 p-6 text-gray-900">
<h1 className="text-3xl font-bold">Oś załogi</h1>
<form onSubmit={handleSubmit} className="mt-4 rounded-lg border border-gray-300 bg-white p-4">
<textarea
value={draft}
onChange={(e) => setDraft(e.target.value)}
rows={3}
placeholder="Co słychać na pokładzie?"
className="w-full rounded border border-gray-300 p-2"
/>
<div className="mt-2 flex gap-2">
<button type="submit" className="rounded bg-blue-600 px-4 py-2 font-semibold text-white">
Wyślij
</button>
<button type="button" onClick={reload} className="rounded border border-gray-300 px-4 py-2">
Wczytaj ponownie
</button>
</div>
</form>
<ul className="mt-4 space-y-4">
{posts.map((post) => (
<li key={post.id}>
<Post
author="Kapitan Redbeard"
avatar="KR"
content={post.content}
likes={0}
time={new Date(post.createdAt).toLocaleTimeString('pl-PL')}
/>
</li>
))}
{crewPosts.map((post) => (
<li key={post.id}>
<Post author={post.author} avatar={post.avatar} content={post.content} likes={post.likes} />
</li>
))}
</ul>
<details className="mt-6 text-sm">
<summary className="cursor-pointer">Co leży w localStorage</summary>
<pre className="mt-2 whitespace-pre-wrap break-all rounded bg-gray-900 p-3 text-green-300">
{JSON.stringify(posts, null, 2)}
</pre>
</details>
</div>
);
}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 zwraca useState(0)?
2. Czym jest druga wartość z tablicy useState, np. setCount?
To 2 z 9 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Edytor kodu
Napisz komponent Counter (export default), czyli licznik łupów. Na górze pliku dodaj 'use client'. Trzymaj liczbę w stanie count z useState(0), wyświetl ją, a obok dodaj przycisk +1, który po każdym kliknięciu zwiększa licznik o 1.
- Układanie w poziomie
Ułóż tokeny deklaracji stanu licznika:
- Klikanie w kolejności
Klikaj tokeny by zablokować przeładowanie strony:
- Układanie w poziomie
Ułóż tokeny zwiększenia licznika o jeden:
- Edytor kodu
Napisz komponent CreatePostForm (export default), czyli formularz wpisu do dziennika pokładowego. Na górze pliku dodaj 'use client'. W znaczniku form umieść pole textarea, którego treść trzymasz w stanie z useState (value i onChange), oraz przycisk wysyłania (button typu submit). W onSubmit wywołaj e.preventDefault() i wyczyść pole.
- Klikanie w kolejności
Klikaj tokeny by zaktualizować stan wartością z inputa:
- Układanie w pionie
Uporządkuj co dzieje się po wysłaniu formularza:
- Układanie w poziomie
Ułóż tokeny, które zamieniają zapisany tekst createdAt na godzinę do wyświetlenia:
- Klikanie w kolejności
Klikaj tokeny by dodać nowy post na początek listy:
- Układanie w pionie
Uporządkuj kroki przeniesienia stanu do rodzica:
- Edytor kodu
Napisz komponent Feed (export default), który łączy formularz z listą postów. Na górze pliku dodaj 'use client'. Posty trzymaj jako tablicę w stanie (useState), a treść nowego posta w osobnym stanie podpiętym do textarea (value i onChange). W onSubmit wywołaj e.preventDefault(), dodaj nowy post na początek listy i wyczyść pole. Posty wyświetl przez map() z propsem key.
- Klikanie w kolejności
Klikaj tokeny by rozpocząć useEffect uruchamiany raz:
- Układanie w pionie
Uporządkuj, co dzieje się z wpisami od otwarcia osi do zapisu:
Zadania po tej lekcji
- PytanieQuiz: useState
- PytanieDruga wartość z useState
- Zadanie z kodemPraktyka: Licznik z useState
- Ułóż w kolejnościDeklaracja useState
- PytanieDodawanie do stanu-tablicy
- PytanieQuiz: Formularze
- Kliknij w kolejnościZbuduj e.preventDefault()
- Ułóż w kolejnościWywołanie settera stanu
- Zadanie z kodemPraktyka: Formularz posta
- PytanieAktualizacja inputa
- Kliknij w kolejnościZbuduj aktualizację stanu z inputa
- Ułóż w kolejnościPrzepływ wysyłania formularza
- Ułóż w kolejnościGodzina z tekstu ISO
- Kliknij w kolejnościZbuduj dodanie do tablicy stanu
- PytanieLifting state up
- Ułóż w kolejnościKroki lifting state up
- Zadanie z kodemPraktyka: Feed z dynamicznymi postami
- PytanieQuiz: useEffect
- PytanieDependency array useEffect
- Kliknij w kolejnościZbuduj wywołanie useEffect
- Ułóż w kolejnościTrwałość wpisów w localStorage
- PytanieZapis do localStorage