Cours Vibe coding avec Claude Code · Module 5: Clone de Reddit
Des fils en arbre : des commentaires qui ne disparaissent pas en silence
Dans cette leçon10
Sous le post sur la route de Tortuga, une discussion s'est enflammée. Morgan veut filer au nord, Redbeard s'inquiète de l'eau potable, Polly met en garde contre les requins et Jack préfère Tortuga. Sur une liste plate, après dix messages, personne ne sait qui répond à qui. Reddit range les réponses en fils avec des retraits, et c'est ce que tu vas construire dans cette leçon ; quant à la fonction qui organise les fils, Claude Code l'écrira de nouveau seulement après les tests.
Problème : une liste plate, un arbre à l'écran
Un jour, les commentaires arriveront d'une base de données sous forme de liste plate. Chacun a un parentId, c'est-à-dire l'id du commentaire auquel il répond, ou null quand il répond directement au post. L'écran a besoin d'autre chose : un commentaire, en dessous ses réponses, en dessous les suivantes. Transformer la liste en un tel arbre, ce sont quelques lignes que l'agent écrit en une minute, et deux endroits où un commentaire peut disparaître sans aucune erreur. Le premier : la réponse figure dans la liste avant son parent, par exemple quand la base renvoie les entrées dans un autre ordre. Le second : le parent n'existe plus, parce que quelqu'un l'a supprimé.
L'arbre et la récursion en un paragraphe
Un arbre est une structure où chaque nœud a une liste d'enfants du même genre, comme un coffret contenant des coffrets. Chez nous, un nœud est un commentaire avec un tableau replies, qui contient à son tour des commentaires avec leurs propres replies. La récursion, c'est une fonction ou un composant qui s'appelle lui-même pour ses enfants. Toute récursion a besoin d'une condition d'arrêt, sinon elle s'appellerait sans fin. Ici, c'est le tableau replies vide.
Demande pour Claude Code
La demande énumère les cas limites explicitement, car le cas heureux, n'importe quelle version le réussit :
Demande pour Claude Code :
Ajoute les commentaires à Crew Council. Un commentaire a id, postId,
parentId (id du parent ou null), author, text et createdAt. Dans
lib/comments.ts, écris buildCommentTree(comments), qui transforme la
liste plate en arbre (chaque nœud a replies), et countTotalComments(arbre).
D'abord les tests dans lib/comments.test.ts : trois niveaux de réponses,
une réponse écrite dans la liste avant son parent, un commentaire sans
parent existant (il reste en haut), la liste plate inchangée après
l'appel, un compteur sur tous les niveaux. Lance les tests avant le code
et après. Ne modifie pas les tests pour qu'ils passent. Ne termine pas
tant que npm run test -- --run n'est pas vert, et montre le résultat."Ne termine pas tant que..." est une condition d'achèvement écrite dans la demande, le degré de rigueur le plus simple des bonnes pratiques de Claude Code. Claude sait à quoi ressemble la fin du travail et peut le vérifier tout seul.
Ce que Claude a écrit : le test de l'arbre
Ouvre lib/comments.test.ts. D'abord la liste plate : deux fils, dont le premier a trois niveaux. makeComment est un assistant de ce fichier qui assemble un commentaire à partir d'un id et d'un parentId et remplit les autres champs avec des constantes :
// c1 -> c2 -> c3 (trois niveaux) et un fil séparé c4
const flat = [
makeComment("c1", null),
makeComment("c2", "c1"),
makeComment("c3", "c2"),
makeComment("c4", null),
];Le premier test vérifie la forme de l'arbre : en haut se tiennent c1 et c4, sous c1 il y a c2, et sous lui c3. Les deux suivants gardent les pièges du début de la leçon :
it("une réponse écrite avant son parent atterrit quand même sous lui", () => {
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("un commentaire sans parent existant reste en haut au lieu de disparaître", () => {
const tree = buildCommentTree([makeComment("c9", "supprime")]);
expect(tree.map((c) => c.id)).toEqual(["c9"]);
});toEqual compare des tableaux entiers, donc l'ordre des id compte aussi. Lis ces tests comme des règles : une réponse ne disparaît pas à cause de l'ordre dans la liste, et un commentaire sans parent ne disparaît pas du tout. Que l'orphelin reste en haut ou disparaisse, c'est ta décision, pas celle de l'agent, et le test la fixe.
La version la plus simple ne suffit pas
La version la plus simple, que les agents écrivent souvent, construit l'arbre en un seul passage : elle parcourt la liste et rattache aussitôt chaque commentaire au parent qu'elle a déjà vu. Nous l'avons essayée avec ces tests :
❯ lib/comments.test.ts (5 tests | 2 failed) 4ms
❯ buildCommentTree (4)
× une réponse écrite avant son parent atterrit quand même sous lui 2ms
× un commentaire sans parent existant reste en haut au lieu de disparaître 0ms
AssertionError: expected [] to deeply equal [ 'c2' ]
Tests 2 failed | 3 passed (5)Trois tests sont passés, dont celui à trois niveaux. À l'écran, avec des données d'exemple, tout aurait l'air bien. Seuls les cas limites ont échoué : la réponse dont le parent est plus loin dans la liste s'est perdue, parce qu'au moment de la lire le parent n'existait pas encore. Voilà à quoi ressemble une erreur qui disparaît en silence : aucun message, simplement un commentaire de moins.
Ce que Claude a écrit : deux passages
Après la correction, lib/comments.ts a deux types. Comment est un commentaire de la liste plate, et CommentNode l'étend d'un champ replies: CommentNode[], c'est-à-dire des enfants du même type. La fonction parcourt la liste deux fois :
export function buildCommentTree(comments: Comment[]): CommentNode[] {
const nodes = new Map<string, CommentNode>();
for (const comment of comments) {
nodes.set(comment.id, { ...comment, replies: [] });
}Map est un dictionnaire : à partir de l'id, tu obtiens tout de suite le nœud, sans fouiller la liste. Le premier passage crée pour chaque commentaire un nouveau nœud avec un tableau de réponses vide. Les commentaires de la liste d'entrée restent intacts, car chaque nœud est une copie faite avec le spread.
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;
}Le second passage connaît déjà tous les nœuds, donc l'ordre dans la liste n'a aucune importance. Un nœud avec un parent existant va dans ses replies, et tous les autres, orphelins compris, au niveau le plus haut. Ici push modifie les tableaux des nouveaux nœuds, pas les données d'entrée. Résultat du nouveau lancement :
Test Files 3 passed (3)
Tests 18 passed (18)Test Files 3, parce que la commande lance les tests de tout le projet, avec le vote, le tri et le pourcentage de votes de la leçon 4_1. L'ancien code a donc été vérifié aussi.
Le compteur : une récursion avec condition d'arrêt
countTotalComments compte les commentaires sur tous les niveaux :
export function countTotalComments(nodes: CommentNode[]): number {
return nodes.reduce((total, node) => total + 1 + countTotalComments(node.replies), 0);
}reduce parcourt les nœuds et accumule une somme, en partant de zéro. Chaque nœud ajoute 1 pour lui-même et le résultat de la même fonction pour ses réponses. La condition d'arrêt se cache dans le tableau vide : pour [], la fonction renvoie aussitôt 0 et ne s'appelle plus.
Ce que Claude a écrit : un fil qui se dessine lui-même
Quand les tests sont verts, vient l'écran. La seconde demande dit où vit l'état et où il n'y a que du dessin :
Maintenant l'écran : la page app/posts/[id]/page.tsx avec le contenu
du post et les commentaires. L'état est la liste plate dans
components/CommentSection.tsx, et l'arbre est calculé par
buildCommentTree à chaque rendu. components/CommentThread.tsx dessine
les réponses récursivement, avec un retrait jusqu'à 4 niveaux, le
repli du fil et un formulaire de réponse. Le titre sur la carte du
post mène à cette page. Commentaires d'exemple dans
lib/comment-data.ts : sous le premier post Morgan, Redbeard répond à
Morgan, Polly à Redbeard, et Jack écrit à part. À la fin, tests, lint
et build.La page app/posts/[id]/page.tsx lit id avec await params comme dans la leçon 2_1 et passe les commentaires du post à components/CommentSection.tsx. Cette section garde la liste plate dans son état et calcule l'arbre à chaque rendu :
const [comments, setComments] = useState(initialComments);
const tree = buildCommentTree(comments);Ainsi, une nouvelle réponse est un seul élément ajouté à la fin de la liste : setComments((prev) => [...prev, comment]), où comment a le parentId du commentaire sous lequel on a cliqué sur Répondre. Pas besoin de chercher le parent au fond de l'arbre ni de copier chaque niveau. components/CommentThread.tsx dessine un commentaire, et en dessous ses réponses :
{!isCollapsed &&
comment.replies.map((reply) => (
<CommentThread key={reply.id} comment={reply} depth={depth + 1} onReply={onReply} />
))}C'est la récursion dans un composant : CommentThread affiche CommentThread pour chaque réponse, avec un depth augmenté de un. Un commentaire sans réponse a un tableau vide, donc map ne dessine rien et la récursion s'arrête. onReply descend à travers tous les niveaux jusqu'au formulaire.
depth commande le retrait. La constante MAX_DEPTH = 4 le limite :
const indent = depth > 0 && depth <= MAX_DEPTH;
return (
<div className={indent ? "ml-4 border-l border-gray-200 pl-3" : ""}>Jusqu'au quatrième niveau, chaque réponse se décale vers la droite de ml-4 et reçoit un trait vertical. Les réponses plus profondes restent sous leur parent sans nouveau retrait, donc une longue dispute ne pousse pas le texte hors du bord droit d'un téléphone. Rien ne disparaît, seul le décalage s'arrête.
Le repli est un état dont seul ce commentaire a besoin, il vit donc en lui. Le bouton [-] le bascule avec setIsCollapsed((prev) => !prev) et porte aria-expanded, pour que le lecteur d'écran sache si le fil est ouvert. Un commentaire replié montre l'auteur et une mention avec le nombre de réponses cachées, calculé par countTotalComments(comment.replies).
La revue du capitaine
- La condition d'arrêt. Quand Claude Code écrit une fonction récursive, trouve d'abord sa condition d'arrêt. Ici c'est le tableau
repliesvide, dans le compteur et dansmap. - Un fil profond sur téléphone. Réponds plusieurs fois de suite au commentaire le plus profond et réduis la fenêtre à la largeur d'un téléphone. À partir du cinquième niveau, le retrait cesse de grandir et le texte reste lisible.
- Le formulaire marche vraiment. Réponds à Polly au niveau le plus profond. La réponse apparaît en retrait sous son commentaire, et le compteur au-dessus de la section passe de 4 à 5. Replie le fil de Morgan : la mention annonce trois réponses cachées. Après un rechargement de la page, la nouvelle réponse disparaît, car elle vit dans l'état du navigateur ; l'enregistrement en base viendra dans les lieux suivants.
- Le contenu en texte. Envoie la réponse
<img src=x onerror=alert(1)>. Elle doit s'afficher comme un simple texte, conformément à la règle de la leçon 3_3 : zérodangerouslySetInnerHTMLdans les commentaires.
L'erreur typique de l'agent ici, tu la connais déjà par les tests : la version en un seul passage. La seconde tentation est de garder l'arbre dans l'état et d'ajouter les réponses avec comment.replies.push(...) sur un objet de l'état. Modifier un objet que React connaît déjà ne rafraîchit pas l'écran et viole la règle "un nouveau tableau plutôt que modifier l'ancien" de la leçon 2_3. Dans le diff, cherche push sur des données d'état.
Étape suivante
Quand tout passe, demande un commit, par exemple "Commentaires : arbre à partir d'une liste plate avec tests, fils et repli". La demande suivante est petite et a des limites :
Pour chaque commentaire qui a des réponses, affiche leur nombre total
même quand le fil est déplié. Utilise countTotalComments.
Ne modifie que @components/CommentThread.tsx.Si Claude réécrit alors plus que ce que tu as demandé, par exemple s'il touche à CommentSection ou aux tests, ne rafistole pas avec une demande de plus. Annule le tour avec /rewind, vu dans la leçon 0_6, et répète la demande avec des mots plus étroits. Dans l'éditeur ci-dessous t'attend un fil construit à partir d'une liste plate : réponds au commentaire le plus profond, replie le fil et compare le compteur des réponses cachées.
À retenir : tu construis l'arbre des fils à partir d'une seule liste plate, et le test vérifie qu'aucune branche n'est tombée en chemin.
Code de cette leçon : App.jsx
// Fils de commentaires : liste plate dans l'état, arbre calculé à chaque rendu
import { useState } from 'react';
const startComments = [
{ id: 'k1', parentId: null, author: 'Morgan', text: "Vers le nord. L'or n'attendra pas." },
{ id: 'k2', parentId: 'k1', author: 'Redbeard', text: 'Et avec quoi étancher la soif en route ?' },
{ id: 'k3', parentId: 'k2', author: 'Polly', text: "Avec l'eau de pluie. Mais il y a des requins au nord." },
{ id: 'k4', parentId: null, author: 'Jack', text: 'Tortuga. Il nous faut de nouveaux bras pour travailler.' },
// Réponse écrite avant son parent : deux passages la retrouveront quand même
{ id: 'k6', parentId: 'k5', author: 'Morgan', text: 'Il faut aussi nourrir les canons.' },
{ id: 'k5', parentId: 'k4', author: 'Polly', text: 'Et de nouveaux barils de poudre.' },
];
const MAX_DEPTH = 4;
function buildCommentTree(comments) {
// Premier passage : un nœud avec un tableau de réponses vide pour chaque commentaire
const nodes = new Map();
for (const comment of comments) {
nodes.set(comment.id, { ...comment, replies: [] });
}
// Second passage : chaque nœud va sous son parent ou au niveau le plus haut
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="Ta réponse..."
aria-label="Texte de la réponse"
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">
Envoyer
</button>
{onCancel && (
<button type="button" onClick={onCancel} className="text-sm text-gray-500">
Annuler
</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 ? 'Développer le fil' : 'Replier le fil'}
className="mr-1 font-mono"
>
{isCollapsed ? '[+]' : '[-]'}
</button>
u/{comment.author}
{isCollapsed && hiddenReplies > 0 && <span> (réponses cachées : {hiddenReplies})</span>}
</p>
{!isCollapsed && (
<>
{/* Contenu en texte brut : React n'exécutera pas le HTML du commentaire */}
<p className="text-sm">{comment.text}</p>
<button type="button" onClick={() => setIsReplying(true)} className="text-xs text-gray-500 hover:underline">
Répondre
</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() seulement ici : cette fonction s'exécute après l'envoi du formulaire
const addComment = (parentId, text) => {
const comment = { id: String(Date.now()), parentId, author: 'Toi', 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">Cap sur Tortuga ou vers le nord ?</h1>
<h2 className="mt-4 font-bold">Commentaires ({comments.length})</h2>
<ReplyForm onSubmit={(text) => addComment(null, text)} />
{tree.map((node) => (
<CommentThread key={node.id} comment={node} onReply={addComment} />
))}
</div>
</div>
);
}Tu as repéré une erreur dans cette leçon ?
Teste tes connaissances
Réponds aux questions de cette leçon. Choisis une réponse pour voir tout de suite si elle est correcte.
1. Pourquoi CommentNode a-t-il le champ 'replies: CommentNode[]' ?
2. Comment rendre des commentaires imbriqués ?
Voici 2 des 7 questions de cette leçon. Réponds aux autres dans le jeu.
Tâches pratiques dans le jeu
- Éditeur de code
Commentaires imbriqués
- Tri vertical
La liste plate contient dans l'ordre : Morgan (parentId null), Redbeard (répond à Morgan), Polly (répond à Redbeard), Jack (parentId null). Ordonne les commentaires comme CommentThread les montrera depuis le haut de l'écran :
- Clique dans l'ordre
Construis le type du champ replies dans l'interface CommentNode en cliquant sur les éléments dans l'ordre :
- Éditeur de code
Réduire un fil de commentaires
- Tri vertical
Ordonne les étapes de la fonction buildCommentTree de la leçon :
- Tri horizontal
Ordonne l'appel qui compte toutes les réponses sous un commentaire, à tous les niveaux (une ligne, de gauche à droite) :
- Tri vertical
Ordonne les commentaires par profondeur d'imbrication croissante :
- Clique dans l'ordre
Clique sur les éléments dans l'ordre pour construire l'appel récursif qui affiche les réponses :
- Tri vertical
Ordonne ce qui se passe après l'envoi d'une réponse sous le commentaire de Polly :
Exercices après cette leçon
- QuestionQuiz : le champ replies de CommentNode
- QuestionQuiz : Composant récursif
- QuestionQuiz : profondeur et indentation
- Exercice de codePratique : Fil de commentaires
- Remets dans l'ordreTri : l'ordre du fil à l'écran
- QuestionQuiz : la limite de retrait MAX_DEPTH
- Clique dans l'ordreClic dans l'ordre : Type de replies
- Exercice de codePratique : Réduire/développer
- QuestionQuiz : Réduire/développer
- QuestionQuiz : Compter les commentaires
- Remets dans l'ordreTri : buildCommentTree pas à pas
- QuestionQuiz : les deux passages de buildCommentTree
- Remets dans l'ordreTri : le nombre de réponses cachées
- Remets dans l'ordreTri : Profondeur d'imbrication
- Clique dans l'ordreClic dans l'ordre : Afficher les réponses
- Remets dans l'ordreTri : le chemin d'une nouvelle réponse