Cours Vibe coding avec Claude Code · Module 3: Clone de Twitter

Le carnet dans la poche du capitaine : useRef dans le formulaire de post

8 min de lecture ·
Dans cette leçon8

Le capitaine écrit plusieurs posts d'affilée et perd son rythme à chaque fois. Après un clic sur « Envoyer », le curseur s'échappe du champ, donc avant le post suivant il faut recliquer dans le champ. Et quand le fil a grandi et que tu l'as fait défiler loin vers le bas, tu reviens au formulaire à coups de molette. Les deux problèmes se ramènent à un seul ordre pour le navigateur : « mets le curseur dans ce champ ». L'état de la leçon 2_3 ne peut pas le donner, car l'état décrit ce qu'il faut dessiner, et non où se trouve le curseur.

useRef en un paragraphe

C'est le travail de useRef, un autre hook de React. L'appel useRef(valeurInitiale) renvoie un objet avec une seule propriété, current, et useRef(0) donne au départ { current: 0 }. React te rend le même objet à chaque rendu, donc ce que tu y écris survit. La différence essentielle avec l'état : modifier current ne rafraîchit pas l'écran.

Dans la leçon 2_3, l'état était le journal de bord, où chaque entrée est un signe pour l'équipage que quelque chose a changé. La ref est le carnet dans la poche du capitaine : il y écrit ce qu'il veut, mais personne à bord n'en est informé. Le carnet sert à deux choses : retenir où se trouve un élément précis de la page, et garder des valeurs que tu ne montres pas à l'écran.

Demande pour Claude Code

Le changement touche un seul fichier et a une forme claire, donc il se passe de plan. Les dernières phrases de la demande protègent ce qui marche déjà.

Demande pour Claude Code :

Dans @components/Feed.tsx : 1) après l'envoi d'un post, remets le
curseur dans le champ textarea pour écrire tout de suite le suivant ;
2) ajoute un bouton « Écrire un post » fixé en bas à droite de
l'écran, qui amène le curseur dans le champ depuis n'importe quel
endroit du fil. Utilise useRef et explique dans ta réponse pourquoi
une ref et pas l'état. Ne touche pas à l'état draft ni au compteur
de caractères. À la fin, npm run build et npm run lint.

La demande d'explication est un test pour Claude : s'il ne sait pas dire pourquoi une ref et pas l'état, il a probablement choisi l'outil à l'aveugle.

Ce que Claude a écrit : le carnet pour le champ du post

Ouvre components/Feed.tsx. Sous les états posts et draft est apparue une ligne, et en haut du fichier useRef a rejoint les imports de react :

const textareaRef = useRef<HTMLTextAreaElement>(null);

Le type entre chevrons dit sur quel élément la ref pointera : HTMLTextAreaElement est le champ <textarea> dans le navigateur. La valeur initiale est null, parce qu'au premier rendu le champ n'est pas encore sur la page. La ref ne désigne rien tant que tu ne l'as pas accrochée à un élément.

L'accrochage tient en un seul attribut sur le champ du formulaire de la leçon 2_3 :

<textarea
  ref={textareaRef}
  value={draft}
  onChange={(e) => setDraft(e.target.value)}

L'attribut ref demande à React de mettre le vrai élément dans textareaRef.current quand le champ apparaît sur la page, et de le remettre à null quand il disparaît. value et onChange restent en place : le champ est toujours contrôlé par l'état.

Le curseur revient à sa place

À la fin de handleSubmit, après avoir vidé le champ, Claude a ajouté une ligne :

setPosts([newPost, ...posts]);
setDraft("");
textareaRef.current?.focus();

focus() est une méthode intégrée de l'élément dans le navigateur : elle y place le curseur. Par défaut, le navigateur fait au passage défiler la page pour que le champ soit visible. Le ?. n'appelle la méthode que si current contient un élément et non null. Ici c'est une prudence honnête, car une ref vide avant le dessin du champ est un état prévu ; dans la leçon 2_8 tu verras ?. utilisé pour balayer une erreur sous le tapis.

Claude a posé le bouton « Écrire un post » à la fin de la section, avec la classe fixed bottom-6 right-6, qui le fixe au coin de l'écran. Son clic fait la même chose : onClick={() => textareaRef.current?.focus()}. Grâce au défilement par défaut, un seul clic t'amène du bas du fil droit dans le champ.

Champ contrôlé ou non contrôlé

Un champ avec value et onChange est le formulaire contrôlé de la leçon 2_3 : React connaît son contenu à chaque rendu. Il existe une autre voie. Un champ non contrôlé reçoit seulement defaultValue, le contenu de départ, et c'est le navigateur qui garde la valeur actuelle. Tu la lis par une ref seulement à l'envoi, par exemple textareaRef.current.value. C'est pratique dans un formulaire simple dont tu n'as besoin de la valeur qu'une fois, à la validation.

Notre champ reste contrôlé, parce que le compteur et le bouton désactivé ont besoin du contenu à chaque rendu. Une exception sans choix : <input type="file">. La valeur d'un champ de choix de fichier ne peut pas être fixée par un script, seul l'utilisateur la choisit, donc un tel champ est toujours non contrôlé et tu le lis par une ref. L'important est qu'un même champ ne mélange pas les deux voies : value et defaultValue ensemble, c'est une erreur. Dans l'éditeur ci-dessous, tu vérifieras le comportement des refs : le bouton donne le focus, le compteur dans une ref augmente sans changer l'écran, et le champ de message est non contrôlé et ne rend son contenu qu'à l'envoi.

Code de cette leçon : App.jsx
// useRef : focus, une valeur sans re-rendu et un champ non contrôlé
import { useRef, useState } from 'react';

export default function App() {
  const inputRef = useRef(null);
  const clicksRef = useRef(0);
  const [log, setLog] = useState('');

  const handleFocus = () => {
    inputRef.current.focus();
  };

  const handleRefClick = () => {
    // Modifier une ref ne met pas l'écran à jour
    clicksRef.current = clicksRef.current + 1;
  };

  const handleSubmit = (e) => {
    e.preventDefault();
    // Champ non contrôlé : on lit la valeur dans le DOM seulement à l'envoi
    setLog('Message : ' + inputRef.current.value + ' (clics enregistrés dans la ref : ' + clicksRef.current + ')');
    inputRef.current.value = '';
  };

  return (
    <div className="min-h-screen bg-slate-900 p-8 text-white">
      <h1 className="text-3xl font-bold mb-6">useRef à bord</h1>
      <form onSubmit={handleSubmit} className="space-y-4">
        <input
          ref={inputRef}
          defaultValue=""
          placeholder="Message à l'équipage"
          className="w-full p-3 rounded text-black"
        />
        <div className="space-x-2">
          <button type="button" onClick={handleFocus} className="bg-blue-600 px-4 py-2 rounded">
            Donner le focus
          </button>
          <button type="button" onClick={handleRefClick} className="bg-amber-600 px-4 py-2 rounded">
            +1 dans la ref (l'écran ne changera pas)
          </button>
          <button type="submit" className="bg-green-600 px-4 py-2 rounded">
            Envoyer
          </button>
        </div>
      </form>
      <p className="mt-6">{log}</p>
    </div>
  );
}

La ref ne rafraîchit pas l'écran

Claude a expliqué son choix à peu près ainsi : le curseur est l'affaire du navigateur et non l'apparence de la page, donc il n'y a rien à redessiner. La même phrase fonctionne dans l'autre sens. Tout ce qui doit apparaître à l'écran doit vivre dans l'état.

Erreur typique d'un agent : Claude « optimise » le formulaire. Il écrit que l'état draft rafraîchit le composant à chaque lettre, donc il rend le champ non contrôlé et garde le contenu dans une ref :

const draftRef = useRef("");
// ...
<span>{draftRef.current.length}/{MAX_LENGTH}</span>

Les lettres apparaissent dans le champ, car c'est le navigateur qui les garde, mais le compteur de caractères reste figé : modifier draftRef.current ne déclenche aucun rendu. La documentation de React dit clairement de ne ni lire ni écrire ref.current pendant le rendu, sauf pour donner la valeur de départ : fais-le dans les gestionnaires d'événements ou dans les effets. npm run lint surveille cette règle avec react-hooks/refs et signale l'erreur Cannot access refs during render. Quand tu la vois, demande de revenir à l'état, et non de faire taire la règle.

La revue du capitaine

Avant de faire le commit, vérifie dans le navigateur et dans le diff :

  1. Le curseur après l'envoi. Envoie un post et continue aussitôt d'écrire, sans cliquer. Les lettres doivent arriver dans le champ.
  2. Le bouton depuis le bas du fil. Fais défiler la page vers le bas et clique sur « Écrire un post » : la page revient au formulaire, et le curseur est dans le champ.
  3. .current seulement dans les gestionnaires d'événements. Ni dans le JSX ni dans le corps du composant il n'y a de lecture de textareaRef.current, et npm run lint passe sans erreur react-hooks/refs.
  4. Pas de forwardRef. Quand le champ vit dans son propre composant, en React 19 tu passes la ref comme une prop ordinaire. La documentation de React dit que forwardRef n'est plus nécessaire et sera marqué comme obsolète, et Claude y recourt parfois à partir de vieux code.

Étape suivante

Demande un commit avec une description du genre « Focus du champ après l'envoi et bouton Écrire un post ». Ensuite, l'autre page du carnet, la valeur qu'on ne voit pas :

Après l'envoi d'un post, montre sous le formulaire de
@components/Feed.tsx un message « Post ajouté » qui disparaît
au bout de 3 secondes. Si j'envoie un deuxième post plus tôt,
le compte à rebours doit repartir de zéro.

Le message ira dans l'état, parce qu'il se voit à l'écran. Le numéro du minuteur de setTimeout ne se voit pas, mais la fonction d'envoi doit le connaître au post suivant, donc Claude le cachera dans le carnet :

setNotice("Post ajouté");
if (noticeTimerRef.current) clearTimeout(noticeTimerRef.current);
noticeTimerRef.current = setTimeout(() => setNotice(""), 3000);

noticeTimerRef naît à côté de l'état comme useRef<ReturnType<typeof setTimeout> | null>(null), c'est-à-dire un carnet pour le numéro du minuteur ou pour le vide. clearTimeout arrête l'ancien compte à rebours avant que le nouveau démarre, donc le deuxième post ne perd pas son message une seconde après l'envoi. Modifier current ne rafraîchit pas l'écran et n'en a pas besoin : c'est setNotice qui change l'écran. Dans l'éditeur ci-dessous t'attend le formulaire de cette leçon : envoie deux posts vite l'un après l'autre et clique sur « Écrire un post ».

Retiens : le journal de bord convoque l'équipage, et le carnet dans la poche du capitaine travaille en silence.

Code de cette leçon : App.jsx
// Formulaire de post avec le carnet du capitaine (useRef) :
// textareaRef désigne le champ, et noticeTimerRef retient le numéro du minuteur.
// Envoie deux posts vite l'un après l'autre, fais défiler vers le bas et clique sur "Écrire un post".
import { useRef, useState } from 'react';

const MAX_LENGTH = 280;

const crewPosts = [
  "Kraken vu près de l'île des Crânes. Cap à l'ouest.",
  'Gouvernail réparé. Qui m’aide avec les voiles ?',
  'Soupe de poisson pour le dîner. Premier arrivé, premier servi !',
  'La carte au trésor sèche sur le pont.',
  'Le maître d’équipage cherche des volontaires pour frotter le pont.',
  'Les mouettes ont encore volé les biscuits.',
];

export default function App() {
  const [posts, setPosts] = useState([]);
  const [draft, setDraft] = useState('');
  const [notice, setNotice] = useState('');
  const textareaRef = useRef(null);
  const noticeTimerRef = useRef(null);

  const handleSubmit = (e) => {
    e.preventDefault();
    if (!draft.trim() || draft.length > MAX_LENGTH) return;

    setPosts([{ id: String(Date.now()), content: draft.trim() }, ...posts]);
    setDraft('');
    // Ref dans un gestionnaire d'événement : le curseur revient dans le champ
    textareaRef.current?.focus();

    // Le message dans l'état, le numéro du minuteur dans la ref
    setNotice('Post ajouté');
    if (noticeTimerRef.current) clearTimeout(noticeTimerRef.current);
    noticeTimerRef.current = setTimeout(() => setNotice(''), 3000);
  };

  return (
    <div className="min-h-screen bg-gray-50 p-6 pb-24 text-gray-900">
      <h1 className="text-3xl font-bold">Le fil de l&apos;équipage</h1>

      <form onSubmit={handleSubmit} className="mt-4 rounded-lg border border-gray-300 bg-white p-4">
        <textarea
          ref={textareaRef}
          value={draft}
          onChange={(e) => setDraft(e.target.value)}
          rows={3}
          placeholder="Quoi de neuf sur le pont ?"
          className="w-full rounded border border-gray-300 p-2"
        />
        <div className="mt-2 flex items-center justify-between">
          {/* Compteur calculé à partir de l'état draft à chaque rendu */}
          <span className={draft.length > MAX_LENGTH * 0.9 ? 'text-sm text-red-600' : 'text-sm text-gray-500'}>
            {draft.length}/{MAX_LENGTH}
          </span>
          <button
            type="submit"
            disabled={!draft.trim() || draft.length > MAX_LENGTH}
            className="rounded bg-blue-600 px-4 py-2 font-semibold text-white disabled:opacity-50"
          >
            Envoyer
          </button>
        </div>
        {notice && <p className="mt-2 text-sm text-green-700">{notice}</p>}
      </form>

      <ul className="mt-4 space-y-4">
        {posts.map((post) => (
          <li key={post.id} className="rounded-lg border border-blue-300 bg-white p-4">
            <p className="font-bold">Capitaine Barbe-Rousse</p>
            <p className="mt-2">{post.content}</p>
          </li>
        ))}
        {crewPosts.map((content) => (
          <li key={content} className="rounded-lg border border-gray-300 bg-white p-4">
            <p className="mt-2 h-24">{content}</p>
          </li>
        ))}
      </ul>

      <button
        type="button"
        onClick={() => textareaRef.current?.focus()}
        className="fixed bottom-6 right-6 rounded-full bg-blue-600 px-5 py-3 font-semibold text-white shadow-lg"
      >
        Écrire un post
      </button>
    </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. 1. Que retourne l'appel useRef(0) ?

  2. 2. Claude a remplacé l'état draft par useRef pour économiser des rendus : le champ est maintenant non contrôlé, et le compteur de caractères lit draftRef.current. Que verras-tu ?

Voici 2 des 3 questions de cette leçon. Réponds aux autres dans le jeu.

Tâches pratiques dans le jeu

  • Tri horizontal

    Ordonne les éléments qui remettent le curseur dans le champ textarea après l'envoi d'un post :

  1. QuestionCe que retourne useRef
  2. QuestionUne ref à la place de l'état
  3. Remets dans l'ordreLe curseur revient dans le champ
  4. QuestionLe champ de fichier est non contrôlé

Articles utiles