Kurs vibe coding z Claude Code · Moduł 5: Klon Reddita

Wątki w drzewie: komentarze, które nie giną po cichu

9 min czytania ·
W tej lekcji10

Pod postem o kursie na Tortugę rozgorzała dyskusja. Morgan chce płynąć na północ, Redbeard pyta o wodę pitną, Polly ostrzega przed rekinami, a Jack woli Tortugę. Na płaskiej liście po dziesięciu wpisach nikt nie wie, kto komu odpowiada. Reddit układa odpowiedzi w wątki z wcięciami i to zbudujesz w tej lekcji, a funkcję, która układa wątki, Claude Code znów napisze dopiero po testach.

Problem: płaska lista, drzewo na ekranie

Komentarze przyjdą kiedyś z bazy danych jako płaska lista. Każdy ma parentId, czyli id komentarza, na który odpowiada, albo null, gdy odpowiada wprost na post. Ekran potrzebuje czegoś innego: komentarza, pod nim jego odpowiedzi, pod nimi kolejnych. Zamiana listy na takie drzewo to kilka linii, które agent pisze w minutę, i dwa miejsca, w których komentarz potrafi zniknąć bez żadnego błędu. Pierwsze: odpowiedź stoi na liście przed swoim rodzicem, na przykład gdy baza zwróci wpisy w innej kolejności. Drugie: rodzica już nie ma, bo ktoś go usunął.

Drzewo i rekurencja w jednym akapicie

Drzewo to struktura, w której każdy węzeł ma listę dzieci tego samego rodzaju, jak szkatułka ze szkatułkami w środku. U nas węzeł to komentarz z tablicą replies, a w niej znowu komentarze z własnymi replies. Rekurencja to funkcja albo komponent, który woła sam siebie dla dzieci. Każda rekurencja potrzebuje warunku końca, inaczej wołałaby się bez końca. Tutaj jest nim pusta tablica replies.

Polecenie dla Claude Code

Polecenie wymienia przypadki brzegowe wprost, bo sam szczęśliwy przypadek zaliczy każda wersja:

Polecenie dla Claude Code:

Dodaj komentarze do Crew Council. Komentarz ma id, postId, parentId
(id rodzica albo null), author, text i createdAt. W lib/comments.ts
napisz buildCommentTree(comments), która zamienia płaską listę w drzewo
(każdy węzeł ma replies), i countTotalComments(drzewo). Najpierw testy
w lib/comments.test.ts: trzy poziomy odpowiedzi, odpowiedź zapisana na
liście przed rodzicem, komentarz bez istniejącego rodzica (zostaje na
górze), płaska lista bez zmian po wywołaniu, licznik na wszystkich
poziomach. Uruchom testy przed kodem i po nim. Nie zmieniaj testów,
żeby przeszły. Nie kończ, dopóki npm run test -- --run nie jest
zielony, i pokaż wynik.

"Nie kończ, dopóki..." to warunek ukończenia wpisany w polecenie, najprostszy stopień rygoru z dobrych praktyk Claude Code. Claude wie, jak wygląda koniec pracy, i może to sprawdzić sam.

Co napisał Claude: test drzewa

Otwórz lib/comments.test.ts. Najpierw płaska lista: dwa wątki, z których pierwszy ma trzy poziomy. makeComment to pomocnik z tego pliku, który składa komentarz z id i parentId, a resztę pól wypełnia stałymi:

// c1 -> c2 -> c3 (trzy poziomy) i osobny wątek c4
const flat = [
  makeComment("c1", null),
  makeComment("c2", "c1"),
  makeComment("c3", "c2"),
  makeComment("c4", null),
];

Pierwszy test sprawdza kształt drzewa: na górze stoją c1 i c4, pod c1 jest c2, a pod nim c3. Dwa kolejne pilnują pułapek z początku lekcji:

it("odpowiedź zapisana przed rodzicem i tak trafia pod rodzica", () => {
  const tree = buildCommentTree([makeComment("c2", "c1"), makeComment("c1", null)]);
  expect(tree.map((c) => c.id)).toEqual(["c1"]);
  expect(tree[0].replies.map((c) => c.id)).toEqual(["c2"]);
});

it("komentarz bez istniejącego rodzica zostaje na górze, zamiast zniknąć", () => {
  const tree = buildCommentTree([makeComment("c9", "usuniety")]);
  expect(tree.map((c) => c.id)).toEqual(["c9"]);
});

toEqual porównuje całe tablice, więc kolejność id też się liczy. Przeczytaj te testy jak zasady: odpowiedź nie znika przez kolejność na liście, a komentarz bez rodzica nie znika wcale. Czy sierota ma stać na górze, czy zniknąć, to Twoja decyzja, nie agenta, i test ją utrwala.

Najprostsza wersja nie wystarcza

Najprostsza wersja, którą agenci często piszą, buduje drzewo w jednym przebiegu: idzie po liście i każdy komentarz od razu dopina do rodzica, którego już widziała. Sprawdziliśmy ją na tych testach:

 ❯ lib/comments.test.ts (5 tests | 2 failed) 4ms
   ❯ buildCommentTree (4)
     × odpowiedź zapisana przed rodzicem i tak trafia pod rodzica 2ms
     × komentarz bez istniejącego rodzica zostaje na górze, zamiast zniknąć 0ms

AssertionError: expected [] to deeply equal [ 'c2' ]

      Tests  2 failed | 3 passed (5)

Trzy testy przeszły, w tym ten z trzema poziomami. Na ekranie z przykładowymi danymi wszystko wyglądałoby dobrze. Zawiodły tylko przypadki brzegowe: odpowiedź, której rodzic stoi dalej na liście, przepadła, bo w chwili jej czytania rodzica jeszcze nie było. Tak wygląda błąd, który ginie po cichu: żadnego komunikatu, po prostu jeden komentarz mniej.

Co napisał Claude: dwa przebiegi

Po poprawce lib/comments.ts ma dwa typy. Comment to komentarz z płaskiej listy, a CommentNode rozszerza go o pole replies: CommentNode[], czyli o dzieci tego samego typu. Funkcja przechodzi listę dwa razy:

export function buildCommentTree(comments: Comment[]): CommentNode[] {
  const nodes = new Map<string, CommentNode>();
  for (const comment of comments) {
    nodes.set(comment.id, { ...comment, replies: [] });
  }

Map to słownik: po id od razu dostajesz węzeł, bez przeszukiwania listy. Pierwszy przebieg tworzy dla każdego komentarza nowy węzeł z pustą tablicą odpowiedzi. Komentarze z listy wejściowej zostają nietknięte, bo każdy węzeł to kopia ze spreadem.

  const roots: CommentNode[] = [];
  for (const node of nodes.values()) {
    const parent = node.parentId ? nodes.get(node.parentId) : undefined;
    if (parent) {
      parent.replies.push(node);
    } else {
      roots.push(node);
    }
  }
  return roots;
}

Drugi przebieg zna już wszystkie węzły, więc kolejność na liście nie ma znaczenia. Węzeł z istniejącym rodzicem trafia do jego replies, a każdy inny, także sierota, na najwyższy poziom. push zmienia tu tablice nowych węzłów, a nie dane wejściowe. Wynik ponownego uruchomienia:

 Test Files  3 passed (3)
      Tests  18 passed (18)

Test Files 3, bo komenda uruchamia testy całego projektu, razem z głosowaniem, sortowaniem i procentem głosów z lekcji 4_1. Stary kod też został sprawdzony.

Licznik: rekurencja z warunkiem końca

countTotalComments liczy komentarze na wszystkich poziomach:

export function countTotalComments(nodes: CommentNode[]): number {
  return nodes.reduce((total, node) => total + 1 + countTotalComments(node.replies), 0);
}

reduce przechodzi po węzłach i zbiera sumę, zaczynając od zera. Każdy węzeł dodaje 1 za siebie i wynik tej samej funkcji dla swoich odpowiedzi. Warunek końca kryje się w pustej tablicy: dla [] funkcja od razu zwraca 0 i dalej się nie woła.

Co napisał Claude: wątek, który rysuje sam siebie

Gdy testy są zielone, czas na ekran. Drugie polecenie mówi, gdzie żyje stan, a gdzie tylko rysunek:

Teraz ekran: strona app/posts/[id]/page.tsx z treścią posta
i komentarzami. Stan trzyma płaska lista w components/CommentSection.tsx,
a drzewo liczy buildCommentTree przy każdym renderze.
components/CommentThread.tsx rysuje odpowiedzi rekurencyjnie, z wcięciem
do 4 poziomów, zwijaniem wątku i formularzem odpowiedzi. Tytuł na karcie
posta prowadzi do tej strony. Przykładowe komentarze w lib/comment-data.ts:
pod pierwszym postem Morgan, Redbeard odpowiada Morganowi, Polly
Redbeardowi, a Jack pisze osobno. Na koniec testy, lint i build.

Strona app/posts/[id]/page.tsx czyta id przez await params jak w lekcji 2_1 i przekazuje komentarze posta do components/CommentSection.tsx. Ta sekcja trzyma w stanie płaską listę, a drzewo wylicza przy każdym renderze:

const [comments, setComments] = useState(initialComments);
const tree = buildCommentTree(comments);

Dzięki temu nowa odpowiedź to jeden element dopisany na koniec listy: setComments((prev) => [...prev, comment]), gdzie comment ma parentId komentarza, pod którym kliknięto Odpowiedz. Nie trzeba szukać rodzica w głębi drzewa ani kopiować każdego poziomu. components/CommentThread.tsx rysuje jeden komentarz, a pod nim swoje odpowiedzi:

{!isCollapsed &&
  comment.replies.map((reply) => (
    <CommentThread key={reply.id} comment={reply} depth={depth + 1} onReply={onReply} />
  ))}

To jest rekurencja w komponencie: CommentThread renderuje CommentThread dla każdej odpowiedzi, z depth większym o jeden. Komentarz bez odpowiedzi ma pustą tablicę, więc map niczego nie rysuje i rekurencja się kończy. onReply wędruje w dół przez wszystkie poziomy aż do formularza.

depth steruje wcięciem. Stała MAX_DEPTH = 4 je ogranicza:

const indent = depth > 0 && depth <= MAX_DEPTH;
return (
  <div className={indent ? "ml-4 border-l border-gray-200 pl-3" : ""}>

Do czwartego poziomu każda odpowiedź przesuwa się w prawo o ml-4 i dostaje pionową linię. Głębsze odpowiedzi stoją pod rodzicem bez kolejnego wcięcia, więc długa kłótnia nie wypycha tekstu za prawą krawędź telefonu. Nic nie znika, kończy się tylko przesuwanie.

Zwijanie to stan, który potrzebny jest tylko temu jednemu komentarzowi, więc mieszka w nim. Przycisk [-] przełącza go przez setIsCollapsed((prev) => !prev) i ma aria-expanded, żeby czytnik ekranu wiedział, czy wątek jest otwarty. Zwinięty komentarz pokazuje autora i dopisek z liczbą ukrytych odpowiedzi, wyliczoną przez countTotalComments(comment.replies).

Przegląd kapitana

  1. Warunek końca. Gdy Claude Code napisze funkcję rekurencyjną, najpierw znajdź jej warunek końca. Tu to pusta tablica replies w liczniku i w map.
  2. Głęboki wątek na telefonie. Odpowiedz kilka razy z rzędu na najgłębszy komentarz i zwęź okno do szerokości telefonu. Od piątego poziomu wcięcie przestaje rosnąć, a tekst zostaje czytelny.
  3. Formularz naprawdę działa. Odpowiedz Polly na najgłębszym poziomie. Odpowiedź pojawia się wcięta pod jej komentarzem, a licznik nad sekcją rośnie z 4 do 5. Zwiń wątek Morgana: dopisek mówi o trzech ukrytych odpowiedziach. Po odświeżeniu strony nowa odpowiedź znika, bo żyje w stanie przeglądarki; zapis w bazie przyjdzie w dalszych lokacjach.
  4. Treść jako tekst. Wyślij odpowiedź <img src=x onerror=alert(1)>. Ma się pokazać jako zwykły napis, zgodnie z zasadą z lekcji 3_3: zero dangerouslySetInnerHTML w komentarzach.

Typowy błąd agenta w tym miejscu znasz już z testów: wersja w jednym przebiegu. Druga pokusa to przechowywanie drzewa w stanie i dopisywanie odpowiedzi przez comment.replies.push(...) na obiekcie ze stanu. Zmiana obiektu, który React już zna, nie odświeża ekranu i łamie zasadę "nowa tablica zamiast zmiany starej" z lekcji 2_3. W diffie szukaj push na danych ze stanu.

Następny krok

Gdy wszystko przejdzie, poproś o commit, na przykład "Komentarze: drzewo z płaskiej listy z testami, wątki i zwijanie". Następne polecenie jest małe i ma granice:

Przy każdym komentarzu, który ma odpowiedzi, pokaż ich łączną liczbę
także wtedy, gdy wątek jest rozwinięty. Użyj countTotalComments.
Zmieniaj tylko @components/CommentThread.tsx.

Jeśli Claude przepisze przy tym więcej, niż prosiłeś, na przykład ruszy CommentSection albo testy, nie łataj tego kolejnym poleceniem. Cofnij turę przez /rewind z lekcji 0_6 i powtórz prośbę węższymi słowami. W edytorze poniżej czeka wątek zbudowany z płaskiej listy: odpowiedz najgłębszemu komentarzowi, zwiń wątek i porównaj licznik ukrytych odpowiedzi.

Pamiętaj: drzewo wątków budujesz z jednej płaskiej listy, a test sprawdza, czy po drodze nie odpadła żadna gałąź.

Kod do tej lekcji: App.jsx
// Wątki komentarzy: płaska lista w stanie, drzewo liczone przy każdym renderze
import { useState } from 'react';

const startComments = [
  { id: 'k1', parentId: null, author: 'Morgan', text: 'Na północ. Złoto nie będzie czekać.' },
  { id: 'k2', parentId: 'k1', author: 'Redbeard', text: 'A czym ugasimy pragnienie po drodze?' },
  { id: 'k3', parentId: 'k2', author: 'Polly', text: 'Deszczówką. Ale na północy są rekiny.' },
  { id: 'k4', parentId: null, author: 'Jack', text: 'Tortuga. Potrzebujemy nowych rąk do pracy.' },
  // Odpowiedź zapisana przed rodzicem: dwa przebiegi i tak ją znajdą
  { id: 'k6', parentId: 'k5', author: 'Morgan', text: 'Armaty też trzeba nakarmić.' },
  { id: 'k5', parentId: 'k4', author: 'Polly', text: 'I nowych beczek prochu.' },
];

const MAX_DEPTH = 4;

function buildCommentTree(comments) {
  // Pierwszy przebieg: węzeł z pustą tablicą odpowiedzi dla każdego komentarza
  const nodes = new Map();
  for (const comment of comments) {
    nodes.set(comment.id, { ...comment, replies: [] });
  }
  // Drugi przebieg: każdy węzeł trafia pod rodzica albo na najwyższy poziom
  const roots = [];
  for (const node of nodes.values()) {
    const parent = node.parentId ? nodes.get(node.parentId) : undefined;
    if (parent) parent.replies.push(node);
    else roots.push(node);
  }
  return roots;
}

function countTotalComments(nodes) {
  return nodes.reduce((total, node) => total + 1 + countTotalComments(node.replies), 0);
}

function ReplyForm({ onSubmit, onCancel }) {
  const [text, setText] = useState('');
  const handleSubmit = (event) => {
    event.preventDefault();
    const value = text.trim();
    if (!value) return;
    onSubmit(value);
    setText('');
  };
  return (
    <form onSubmit={handleSubmit} className="mt-2 flex gap-2">
      <input
        value={text}
        onChange={(event) => setText(event.target.value)}
        placeholder="Twoja odpowiedź..."
        aria-label="Treść odpowiedzi"
        className="flex-1 rounded border border-gray-300 px-2 py-1 text-sm"
      />
      <button type="submit" disabled={!text.trim()} className="text-sm font-semibold text-blue-600 disabled:text-blue-300">
        Wyślij
      </button>
      {onCancel && (
        <button type="button" onClick={onCancel} className="text-sm text-gray-500">
          Anuluj
        </button>
      )}
    </form>
  );
}

function CommentThread({ comment, depth = 0, onReply }) {
  const [isCollapsed, setIsCollapsed] = useState(false);
  const [isReplying, setIsReplying] = useState(false);
  const hiddenReplies = countTotalComments(comment.replies);
  const indent = depth > 0 && depth <= MAX_DEPTH;

  return (
    <div className={indent ? 'ml-4 border-l border-gray-200 pl-3' : ''}>
      <div className="py-2">
        <p className="text-xs text-gray-500">
          <button
            type="button"
            onClick={() => setIsCollapsed((prev) => !prev)}
            aria-expanded={!isCollapsed}
            aria-label={isCollapsed ? 'Rozwiń wątek' : 'Zwiń wątek'}
            className="mr-1 font-mono"
          >
            {isCollapsed ? '[+]' : '[-]'}
          </button>
          u/{comment.author}
          {isCollapsed && hiddenReplies > 0 && <span> (ukryte odpowiedzi: {hiddenReplies})</span>}
        </p>
        {!isCollapsed && (
          <>
            {/* Treść jako zwykły tekst: React nie wykona HTML z komentarza */}
            <p className="text-sm">{comment.text}</p>
            <button type="button" onClick={() => setIsReplying(true)} className="text-xs text-gray-500 hover:underline">
              Odpowiedz
            </button>
            {isReplying && (
              <ReplyForm
                onSubmit={(text) => {
                  onReply(comment.id, text);
                  setIsReplying(false);
                }}
                onCancel={() => setIsReplying(false)}
              />
            )}
          </>
        )}
      </div>
      {!isCollapsed &&
        comment.replies.map((reply) => (
          <CommentThread key={reply.id} comment={reply} depth={depth + 1} onReply={onReply} />
        ))}
    </div>
  );
}

export default function App() {
  const [comments, setComments] = useState(startComments);
  const tree = buildCommentTree(comments);

  // Date.now() tylko tutaj: ta funkcja działa po wysłaniu formularza
  const addComment = (parentId, text) => {
    const comment = { id: String(Date.now()), parentId, author: 'Ty', text };
    setComments((prev) => [...prev, comment]);
  };

  return (
    <div className="min-h-screen bg-gray-100 p-4 text-gray-900">
      <div className="mx-auto max-w-xl rounded-lg bg-white p-4">
        <h1 className="text-xl font-bold">Płyniemy na Tortugę czy na północ?</h1>
        <h2 className="mt-4 font-bold">Komentarze ({comments.length})</h2>
        <ReplyForm onSubmit={(text) => addComment(null, text)} />
        {tree.map((node) => (
          <CommentThread key={node.id} comment={node} onReply={addComment} />
        ))}
      </div>
    </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. Dlaczego CommentNode ma pole 'replies: CommentNode[]'?

  2. 2. Jak renderować zagnieżdżone komentarze?

To 2 z 7 pytań do tej lekcji. Pozostałe rozwiążesz w grze.

Zadania praktyczne w grze

  • Edytor kodu

    Threaded comments

  • Układanie w pionie

    Płaska lista ma kolejno: Morgan (parentId null), Redbeard (odpowiada Morganowi), Polly (odpowiada Redbeardowi), Jack (parentId null). Ułóż komentarze tak, jak CommentThread pokaże je od góry ekranu:

  • Klikanie w kolejności

    Zbuduj typ pola replies w interfejsie CommentNode, klikając tokeny w kolejności:

  • Edytor kodu

    Collapse comment thread

  • Układanie w pionie

    Uporządkuj kroki funkcji buildCommentTree z lekcji:

  • Układanie w poziomie

    Ułóż wywołanie, które liczy wszystkie odpowiedzi pod komentarzem, na wszystkich poziomach (jedna linia, od lewej do prawej):

  • Układanie w pionie

    Uporządkuj komentarze według rosnącej głębokości (depth) zagnieżdżenia:

  • Klikanie w kolejności

    Zbuduj wywołanie rekurencyjnego renderowania odpowiedzi, klikając tokeny w kolejności:

  • Układanie w pionie

    Uporządkuj, co dzieje się po wysłaniu odpowiedzi pod komentarzem Polly:

  1. PytanieQuiz: Pole replies w CommentNode
  2. PytanieQuiz: Recursive component
  3. PytanieQuiz: Depth i wcięcia
  4. Zadanie z kodemPraktyka: Comment thread
  5. Ułóż w kolejnościSortowanie: Kolejność wątku na ekranie
  6. PytanieQuiz: Limit wcięcia MAX_DEPTH
  7. Kliknij w kolejnościSekwencja: Typ replies
  8. Zadanie z kodemPraktyka: Collapse/Expand
  9. PytanieQuiz: Collapse/Expand
  10. PytanieQuiz: Liczenie komentarzy
  11. Ułóż w kolejnościSortowanie: buildCommentTree krok po kroku
  12. PytanieQuiz: Dwa przebiegi buildCommentTree
  13. Ułóż w kolejnościSortowanie: Liczba ukrytych odpowiedzi
  14. Ułóż w kolejnościSortowanie: Głębokość zagnieżdżenia
  15. Kliknij w kolejnościSekwencja: Render replies
  16. Ułóż w kolejnościSortowanie: Droga nowej odpowiedzi

Przydatne artykuły