Cours Vibe coding avec Claude Code · Module 3: Clone de Twitter
Le journal de bord : l'état, les J'aime et un nouveau post
Dans cette leçon8
La messagerie ressemble à une vraie mais rien n'y réagit. Le bouton J'aime reste immobile, et on ne peut pas ajouter de nouveau post. L'idée la plus simple, une variable ordinaire dans le composant, ne marchera pas :
function LikeButton() {
let likes = 0;
return (
<button onClick={() => { likes++; console.log(likes); }}>
J'aime ({likes})
</button>
);
}La console affichera 1, 2, 3, mais à l'écran il restera 0. React ne sait pas que la variable a changé, donc il ne redessine pas le composant. Et s'il le redessinait, likes repartirait de zéro, car à chaque rendu la fonction du composant s'exécute depuis le début. Il faut une mémoire qui survit entre les rendus, et un signal « les données ont changé, rafraîchis l'écran ».
useState en une ligne
Les deux, c'est useState qui les donne, un hook de React. Un hook est une fonction au préfixe use que tu appelles au plus haut niveau du composant, jamais dans une condition ni dans une boucle. Pense au journal de bord : le capitaine y note l'état du navire, et chaque nouvelle entrée est un signe pour l'équipage que quelque chose a changé. Toute la déclaration tient en une ligne :
const [count, setCount] = useState(0);useState(0) crée un état avec la valeur initiale 0 et renvoie un tableau de deux éléments : count est la valeur actuelle, et setCount est le setter, la fonction pour la changer. L'appel setCount(count + 1) enregistre la nouvelle valeur et demande à React de redessiner le composant. Le setter ne change pas la variable tout de suite : dans l'appel en cours, count garde l'ancienne valeur, et la nouvelle apparaîtra au rendu suivant. L'état vit dans le navigateur, donc le fichier qui l'utilise commence par "use client" de la leçon 2_2.
Demande pour Claude Code
La fonctionnalité touche quatre fichiers et laisse des choix, par exemple où garder les posts et comment les enregistrer, donc tu commences par un plan, comme dans la leçon 2_1.
Demande pour Claude Code :
/plan Donne vie au fil de la messagerie. 1) Le bouton J'aime comme
Client Component à part dans components/LikeButton.tsx ; le nombre
part de la prop likes de @components/Post.tsx. 2) Au-dessus des posts
de @lib/posts.ts, un formulaire de nouveau post avec un champ
textarea ; le nouveau post du capitaine arrive en haut, avec l'heure
d'ajout. 3) Les nouveaux posts s'enregistrent dans localStorage et
reviennent après l'actualisation. "use client" seulement dans les
fichiers avec état, Post reste sans directive. Après chaque étape,
npm run build et npm run lint.Le plan doit citer les nouveaux fichiers components/LikeButton.tsx et components/Feed.tsx et les modifications de components/Post.tsx et de app/feed/page.tsx. Accepte-le par Yes, manually approve edits et lis chaque modification.
Ce que Claude a écrit : le bouton J'aime
Ouvre components/LikeButton.tsx. Voici tout le fichier :
"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"
>
J'aime ({likes})
</button>
);
}onClick réagit au clic, et le setter augmente le nombre. La prop initialLikes ne change pas : elle ne donne que la valeur de départ, et ensuite c'est l'état likes qui vit. Dans Post.tsx, la ligne <LikeButton initialLikes={likes} /> a remplacé l'ancien bouton, et Post lui-même n'a toujours pas de directive. Vers le navigateur ne part donc que le code du bouton, comme le conseillait la leçon 2_2.
Ce que Claude a écrit : le fil avec le formulaire
Ouvre components/Feed.tsx. En haut du fichier, Claude a décrit le post du formulaire et la fonction qui lit les posts enregistrés :
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 est un petit magasin dans le navigateur qui garde des textes sous des clés. Tu transformes le tableau en texte avec JSON.stringify, et tu le ramènes avec JSON.parse. Remarque createdAt: string : l'heure d'ajout est un texte au format ISO, par exemple 2026-11-14T09:30:00.000Z. Pourquoi pas Date, la revue du capitaine l'expliquera.
Le composant commence par une protection et deux états :
use(browser("Les posts du formulaire sont enregistrés dans localStorage."));
const [posts, setPosts] = useState<CrewPost[]>(loadPosts);
const [draft, setDraft] = useState("");posts est le tableau de posts, et draft est le contenu du champ. En haut du fichier se trouvent les imports use, useEffect et useState de react, et browser de react-dom. À la place d'une valeur initiale, useState a reçu la fonction loadPosts : React l'appelle une seule fois, au premier rendu, donc les posts enregistrés sont en place avant que quoi que ce soit n'apparaisse à l'écran. La première ligne est une nouveauté de React 19.3 : use(browser(...)) dit « ce composant, dessine-le seulement dans le navigateur ». Next.js rend aussi les Client Components sur le serveur pendant le build, et là localStorage n'existe pas. Sans cette ligne, le build finit par l'erreur ReferenceError: localStorage is not defined. Si Claude ne connaît pas ce motif, demande-lui de consulter la documentation dans node_modules/next/dist/docs/, comme le lui dit AGENTS.md.
Le formulaire et le nouveau post en haut
Claude a relié le champ du formulaire à l'état draft. En abrégé, sans les classes Tailwind, cela donne :
<form onSubmit={handleSubmit}>
<textarea value={draft} onChange={(e) => setDraft(e.target.value)} rows={3} />
<button type="submit">Envoyer</button>
</form>C'est un formulaire contrôlé : le champ affiche la valeur de l'état (value), et onChange enregistre chaque changement par e.target.value. Ainsi tu sais à tout moment ce que contient le champ, et tu le vides d'un seul appel du setter. L'envoi est géré par la fonction 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("");
};Après la validation d'un formulaire, le navigateur recharge par défaut la page, et alors tout l'état disparaît ; e.preventDefault() l'empêche. Le type React.SubmitEvent<HTMLFormElement> décrit justement cet événement d'envoi du formulaire. trim() coupe les espaces, donc un post vide ne partira pas. setPosts([newPost, ...posts]) crée un nouveau tableau : le nouveau post au début, et ...posts, l'opérateur spread, copie derrière lui les anciens éléments. L'ancien tableau reste intact, et React reçoit un nouveau tableau, donc il sait qu'il faut rafraîchir l'écran. Chaque post, Claude l'affiche avec le composant Post, qui a reçu une prop facultative time de valeur new Date(post.createdAt).toLocaleTimeString("fr-FR") : le texte ne devient une date qu'au moment de l'affichage.
L'effet : enregistrer après chaque changement
Il reste l'enregistrement. Un seul effet s'en charge :
useEffect(() => {
localStorage.setItem(STORAGE_KEY, JSON.stringify(posts));
}, [posts]);L'écriture dans localStorage est un effet de bord : quelque chose que le composant fait en dehors du dessin de l'écran. C'est à cela que sert useEffect. React lance l'effet après le rendu, et le deuxième argument, le tableau de dépendances, dit quand. [posts] signifie « après le premier rendu et après chaque rendu où le tableau posts a changé » ; un tableau vide [] lance l'effet une seule fois, après le premier rendu, c'est-à-dire au montage du composant, et l'absence de tableau le lance après chaque rendu. En mode développement, l'App Router active le Strict Mode, qui lance chaque effet une fois de plus pour déceler les erreurs ; une double écriture des mêmes posts ne gâche rien.
Dans app/feed/page.tsx, Claude a enveloppé <Feed /> dans <Suspense fallback={<p>Chargement de tes posts...</p>}>. Pendant le build, le serveur y laisse le texte du fallback, et le navigateur le remplace par le formulaire et les posts. Sans cette protection, le build s'interrompt aussi. La page du fil reste un Server Component : les posts de lib/posts.ts viennent du serveur, et dans le navigateur seul Feed travaille. Les posts du formulaire n'ont pas de lien « Ouvrir le post », car ils ne vivent que dans ton navigateur et le serveur ne les connaît pas.
La revue du capitaine
Ajoute deux posts, clique sur quelques J'aime, actualise la page et vérifie :
- L'heure après l'actualisation. L'erreur typique de l'agent est
createdAt: Datedans l'interface etnew Date()à la création du post. Avant l'actualisation, tout marche, et après, Next.js affiche cette erreur :
Runtime TypeError
post.createdAt.toLocaleTimeString is not a functionJSON.stringify a transformé la date en texte, et JSON.parse ne la retransforme pas, donc dans l'état il y a une chaîne et non un Date. TypeScript ne l'attrape pas, car JSON.parse renvoie le type any, que le compilateur croit sur parole : le build et le lint passent. La correction, c'est un texte ISO dans l'interface et new Date(...) seulement à l'affichage, comme dans le code ci-dessus. Dans le diff, cherche le mot Date dans les types de données qui vont dans localStorage.
- Une copie, pas une mutation. Dans le code, il n'y a ni
posts.push(newPost)nipost.likes++.pushmodifie le tableau existant et n'appelle pas le setter, et mêmesetPosts(posts)après lui ne servirait à rien, car React reçoit le même tableau et juge que rien n'a changé. - L'état dans le bon composant. Le nombre de J'aime n'est utile qu'au bouton, donc il vit dans
LikeButton. Les posts sont nécessaires au formulaire comme à la liste, donc ils vivent dans leur parent commun,Feed. Une confusion fréquente : Claude découpeFeedenCreatePostFormetPostList, chacun avec son propreuseStatede posts, et le formulaire ajoute à un tableau que la liste ne voit pas. Le remède s'appelle lifting state up : l'état monte vers le parent :
<CreatePostForm onAdd={(newPost) => setPosts([newPost, ...posts])} />
<PostList posts={posts} />Les données descendent comme props, et les changements remontent par une fonction : le formulaire ne change pas l'état lui-même, il appelle onAdd, et le parent met à jour le tableau, que les deux enfants reçoivent alors identique.
- Un lint sans le faire taire. Si Claude charge les posts dans
useEffectparsetPosts,npm run lintsignalera la règlereact-hooks/set-state-in-effect. N'accepte pas un commentaireeslint-disable, demande plutôt de charger dansuseState(loadPosts).
Étape suivante
Quand la liste passe, demande un commit avec une description du genre « Fil : J'aime, formulaire de post et enregistrement dans localStorage ». Si Claude a réécrit au passage la moitié du fil, /rewind avec l'option Restore code revient à l'état d'avant la demande. Puis une petite extension :
Ajoute sous le champ de @components/Feed.tsx un compteur de caractères
du genre « 12/280 ». Limite de 280 caractères, compteur rouge au-delà
de 90 % de la limite, bouton Envoyer désactivé pour un post vide ou
trop long. Ne change rien d'autre.Le compteur n'a pas besoin d'un nouvel état, car le nombre de caractères se calcule avec draft.length à chaque rendu. Si Claude ajoute un useState séparé pour le compteur, demande-lui pourquoi. Dans l'éditeur ci-dessous t'attend un fil à cliquer : aime un post, ajoute-en un nouveau et clique sur « Recharger » pour voir que l'heure a survécu à l'enregistrement comme texte.
Retiens : l'état est le journal de bord du composant, et la date, tu l'emportes à terre comme un texte, pour ne la transformer en calendrier qu'à la lecture.
Code de cette leçon : App.jsx
// Fil de la messagerie : J'aime, formulaire de nouveau post et enregistrement dans localStorage.
// Dans Next.js, tu dessines ce composant seulement dans le navigateur : use(browser()) et <Suspense>.
// Ici il n'y a pas de serveur, donc localStorage est disponible tout de suite.
import { useEffect, useState } from 'react';
import Post from './components/Post';
const STORAGE_KEY = 'kraken-posts';
// Les posts de l'équipage, qui dans le projet se trouvent dans lib/posts.ts
const crewPosts = [
{ id: '1', author: 'Anne Bonny', avatar: 'AB', content: "Kraken aperçu près de l'île du Crâne. Cap à l'ouest.", likes: 12 },
{ id: '2', author: 'Jack Rackham', avatar: 'JR', content: "Gouvernail réparé. Qui m'aide avec les voiles ?", likes: 5 },
];
function loadPosts() {
const saved = localStorage.getItem(STORAGE_KEY);
return saved ? JSON.parse(saved) : [];
}
export default function App() {
// Démarrage paresseux : loadPosts s'exécute une fois, au premier rendu
const [posts, setPosts] = useState(loadPosts);
const [draft, setDraft] = useState('');
// Enregistrement après le premier rendu et après chaque changement de 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(), // texte ISO, et non un objet Date
};
setPosts([newPost, ...posts]); // nouveau tableau, nouveau post en haut
setDraft('');
};
// Simule l'actualisation de la page : les posts reviennent de localStorage via 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">Le fil de l'équipage</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="Quoi de neuf à bord ?"
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">
Envoyer
</button>
<button type="button" onClick={reload} className="rounded border border-gray-300 px-4 py-2">
Recharger
</button>
</div>
</form>
<ul className="mt-4 space-y-4">
{posts.map((post) => (
<li key={post.id}>
<Post
author="Capitaine Barbe-Rousse"
avatar="KR"
content={post.content}
likes={0}
time={new Date(post.createdAt).toLocaleTimeString('fr-FR')}
/>
</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">Ce qu'il y a dans 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>
);
}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. Que retourne useState(0) ?
2. Quelle est la deuxième valeur du tableau useState, par exemple setCount ?
Voici 2 des 9 questions de cette leçon. Réponds aux autres dans le jeu.
Tâches pratiques dans le jeu
- Éditeur de code
Écris un composant Counter (export default), un compteur de butin. Ajoute 'use client' en haut du fichier. Garde le nombre dans un état count avec useState(0), affiche-le et ajoute à côté un bouton +1 qui augmente le compteur de 1 à chaque clic.
- Tri horizontal
Ordonne les éléments d'une déclaration d'état pour le compteur :
- Clique dans l'ordre
Clique sur les éléments pour bloquer le rechargement de la page :
- Tri horizontal
Ordonne les éléments qui augmentent le compteur de un :
- Éditeur de code
Écris un composant CreatePostForm (export default), le formulaire du journal de bord du capitaine. Ajoute 'use client' en haut du fichier. Dans une balise form, place un textarea dont le contenu est gardé dans un état useState (value et onChange) et un bouton d'envoi (un button de type submit). Dans onSubmit, appelle e.preventDefault() et vide le champ.
- Clique dans l'ordre
Clique sur les éléments pour mettre à jour l'état avec la valeur de l'input :
- Tri vertical
Ordonne ce qui se passe après la soumission d'un formulaire :
- Tri horizontal
Ordonne les éléments qui transforment le texte createdAt enregistré en heure à afficher :
- Clique dans l'ordre
Clique sur les éléments pour ajouter un nouveau post au début de la liste :
- Tri vertical
Ordonne les étapes pour faire remonter l'état vers le parent :
- Éditeur de code
Écris un composant Feed (export default) qui relie le formulaire à la liste des posts. Ajoute 'use client' en haut du fichier. Garde les posts dans un état tableau avec useState et le texte du nouveau post dans un état séparé relié à un textarea (value et onChange). À l'envoi du formulaire, appelle e.preventDefault(), ajoute le nouveau post en haut de la liste et vide le champ. Affiche les posts avec map() et une prop key.
- Clique dans l'ordre
Clique sur les éléments pour démarrer un useEffect qui s'exécute une seule fois :
- Tri vertical
Ordonne ce qui arrive aux posts, de l'ouverture du fil jusqu'à l'enregistrement :
Exercices après cette leçon
- QuestionQuiz : useState
- QuestionLa deuxième valeur de useState
- Exercice de codePratique : Compteur avec useState
- Remets dans l'ordreDéclaration useState
- QuestionAjouter à un état tableau
- QuestionQuiz : Formulaires
- Clique dans l'ordreConstruire e.preventDefault()
- Remets dans l'ordreAppeler le setter de l'état
- Exercice de codePratique : Formulaire Post
- QuestionMettre à jour un input
- Clique dans l'ordreConstruire une mise à jour d'état depuis un input
- Remets dans l'ordreFlux de soumission du formulaire
- Remets dans l'ordreL'heure à partir du texte ISO
- Clique dans l'ordreConstruire l'ajout à un état tableau
- QuestionFaire remonter l'état
- Remets dans l'ordreÉtapes pour faire remonter l'état
- Exercice de codePratique : Fil d'actualité avec posts dynamiques
- QuestionQuiz : useEffect
- QuestionTableau de dépendances de useEffect
- Clique dans l'ordreConstruire un appel useEffect
- Remets dans l'ordrePersistance des posts dans localStorage
- QuestionSauvegarder dans localStorage