Kurs vibe coding z Claude Code · Moduł 3: Klon Twittera

Dziennik pokładowy: stan, polubienia i nowy wpis

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

  1. Godzina po odświeżeniu. Typowy błąd agenta to createdAt: Date w interfejsie i new 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 function

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

  1. Kopia, nie mutacja. W kodzie nie ma posts.push(newPost) ani post.likes++. push zmienia istniejącą tablicę i nie wywołuje settera, a nawet setPosts(posts) po nim nic nie da, bo React dostaje tę samą tablicę i uznaje, że nic się nie zmieniło.
  2. 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 dzieli Feed na CreatePostForm i PostList, każdy z własnym useState wpisó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ą.

  1. Lint bez wyciszania. Jeśli Claude wczytuje wpisy w useEffect przez setPosts, npm run lint zgłosi regułę react-hooks/set-state-in-effect. Nie zgadzaj się na komentarz eslint-disable, tylko poproś o wczytanie w useState(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. 1. Co zwraca useState(0)?

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

  1. PytanieQuiz: useState
  2. PytanieDruga wartość z useState
  3. Zadanie z kodemPraktyka: Licznik z useState
  4. Ułóż w kolejnościDeklaracja useState
  5. PytanieDodawanie do stanu-tablicy
  6. PytanieQuiz: Formularze
  7. Kliknij w kolejnościZbuduj e.preventDefault()
  8. Ułóż w kolejnościWywołanie settera stanu
  9. Zadanie z kodemPraktyka: Formularz posta
  10. PytanieAktualizacja inputa
  11. Kliknij w kolejnościZbuduj aktualizację stanu z inputa
  12. Ułóż w kolejnościPrzepływ wysyłania formularza
  13. Ułóż w kolejnościGodzina z tekstu ISO
  14. Kliknij w kolejnościZbuduj dodanie do tablicy stanu
  15. PytanieLifting state up
  16. Ułóż w kolejnościKroki lifting state up
  17. Zadanie z kodemPraktyka: Feed z dynamicznymi postami
  18. PytanieQuiz: useEffect
  19. PytanieDependency array useEffect
  20. Kliknij w kolejnościZbuduj wywołanie useEffect
  21. Ułóż w kolejnościTrwałość wpisów w localStorage
  22. PytanieZapis do localStorage

Przydatne artykuły