Kurs vibe coding z Claude Code · Moduł 3: Klon Twittera
Notes w kieszeni kapitana: useRef w formularzu wpisu
W tej lekcji8
Kapitan pisze kilka wpisów pod rząd i co chwilę traci rytm. Po kliknięciu "Wyślij" kursor ucieka z pola, więc przed następnym wpisem trzeba znów kliknąć w pole. A gdy oś urośnie i przewiniesz ją daleko w dół, do formularza wracasz kółkiem myszy. Oba problemy sprowadzają się do jednego rozkazu dla przeglądarki: "ustaw kursor w tym polu". Stan z lekcji 2_3 go nie wyda, bo stan opisuje, co narysować, a nie gdzie stoi kursor.
useRef w jednym akapicie
Do tego służy useRef, kolejny hook Reacta. Wywołanie useRef(wartośćPoczątkowa) zwraca obiekt z jedną właściwością current, a useRef(0) daje na start { current: 0 }. React oddaje Ci ten sam obiekt przy każdym renderze, więc to, co w nim zapiszesz, przetrwa. Najważniejsza różnica wobec stanu: zmiana current nie odświeża ekranu.
W lekcji 2_3 stan był dziennikiem pokładowym, w którym każdy wpis to znak dla załogi, że coś się zmieniło. Ref to notes w kieszeni kapitana: kapitan zapisuje w nim, co chce, ale nikt na pokładzie się o tym nie dowiaduje. Notes przydaje się do dwóch rzeczy: do zapamiętania, gdzie stoi konkretny element strony, i do wartości, których nie pokazujesz na ekranie.
Polecenie dla Claude Code
Zmiana dotyczy jednego pliku i ma jasny kształt, więc obejdzie się bez planu. Ostatnie zdania polecenia chronią to, co już działa.
Polecenie dla Claude Code:
W @components/Feed.tsx: 1) po wysłaniu wpisu przywróć kursor do pola
textarea, żeby od razu pisać następny; 2) dodaj przycisk "Napisz wpis"
przypięty w prawym dolnym rogu ekranu, który z dowolnego miejsca osi
przenosi kursor do pola. Użyj useRef i wyjaśnij w odpowiedzi, dlaczego
ref, a nie stan. Stanu draft i licznika znaków nie ruszaj. Na koniec
npm run build i npm run lint.Prośba o wyjaśnienie to test dla Claude: jeśli nie umie powiedzieć, czemu ref, a nie stan, prawdopodobnie wybrał narzędzie na ślepo.
Co napisał Claude: notes na pole wpisu
Otwórz components/Feed.tsx. Pod stanami posts i draft doszła jedna linia, a na górze pliku useRef dołączył do importów z react:
const textareaRef = useRef<HTMLTextAreaElement>(null);Typ w nawiasach ostrych mówi, na jaki element ref będzie wskazywał: HTMLTextAreaElement to pole <textarea> w przeglądarce. Wartość początkowa to null, bo przy pierwszym renderze pola jeszcze nie ma na stronie. Sam ref niczego nie wskazuje, dopóki nie podepniesz go do elementu.
Podpięcie to jeden atrybut na polu formularza z lekcji 2_3:
<textarea
ref={textareaRef}
value={draft}
onChange={(e) => setDraft(e.target.value)}Atrybut ref każe Reactowi wpisać prawdziwy element do textareaRef.current, gdy pole pojawi się na stronie, i wyczyścić go z powrotem na null, gdy zniknie. value i onChange zostają na miejscu: pole dalej jest kontrolowane przez stan.
Kursor wraca na miejsce
Na końcu handleSubmit, po wyczyszczeniu pola, Claude dopisał jedną linię:
setPosts([newPost, ...posts]);
setDraft("");
textareaRef.current?.focus();focus() to wbudowana metoda elementu w przeglądarce: ustawia w nim kursor. Domyślnie przeglądarka przy okazji przewija stronę tak, żeby pole było widać. Znak ?. wywoła metodę tylko wtedy, gdy w current siedzi element, a nie null. Tutaj to uczciwa ostrożność, bo pusty ref przed narysowaniem pola jest przewidzianym stanem; w lekcji 2_8 zobaczysz ?. użyte do zamiatania błędu pod dywan.
Przycisk "Napisz wpis" Claude postawił na końcu sekcji, z klasą fixed bottom-6 right-6, która przypina go do rogu ekranu. Jego obsługa kliknięcia to ta sama linia: onClick={() => textareaRef.current?.focus()}. Dzięki domyślnemu przewijaniu jedno kliknięcie przenosi Cię z dołu osi prosto do pola.
Pole kontrolowane czy niekontrolowane
Pole z value i onChange to formularz kontrolowany z lekcji 2_3: React zna jego treść przy każdym renderze. Jest też druga droga. Pole niekontrolowane dostaje tylko defaultValue, czyli treść startową, a aktualną wartość trzyma przeglądarka. Odczytujesz ją przez ref dopiero przy wysyłce, na przykład textareaRef.current.value. To wygodne w prostym formularzu, z którego potrzebujesz wartości raz, przy zatwierdzeniu.
Nasze pole zostaje kontrolowane, bo licznik i wyłączony przycisk potrzebują treści przy każdym renderze. Wyjątek bez wyboru to <input type="file">: wartości pola wyboru pliku nie da się ustawić ze skryptu, wybiera ją tylko użytkownik, więc takie pole zawsze jest niekontrolowane i czytasz je przez ref. Ważne, żeby jedno pole nie mieszało obu dróg: value i defaultValue naraz to błąd. W edytorze poniżej sprawdzisz zachowania refa: przycisk ustawia focus, licznik w refie rośnie bez zmiany ekranu, a pole wiadomości jest niekontrolowane i oddaje treść dopiero przy wysyłce.
Kod do tej lekcji: App.jsx
// useRef: focus, wartość bez renderowania i pole niekontrolowane
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 = () => {
// Zmiana ref nie odświeża ekranu
clicksRef.current = clicksRef.current + 1;
};
const handleSubmit = (e) => {
e.preventDefault();
// Pole niekontrolowane: wartość czytamy z DOM dopiero przy wysyłce
setLog('Wiadomość: ' + inputRef.current.value + ' (kliknięcia zapisane w 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 na pokładzie</h1>
<form onSubmit={handleSubmit} className="space-y-4">
<input
ref={inputRef}
defaultValue=""
placeholder="Wiadomość do załogi"
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">
Ustaw focus
</button>
<button type="button" onClick={handleRefClick} className="bg-amber-600 px-4 py-2 rounded">
+1 do ref (ekran się nie zmieni)
</button>
<button type="submit" className="bg-green-600 px-4 py-2 rounded">
Wyślij
</button>
</div>
</form>
<p className="mt-6">{log}</p>
</div>
);
}Ref nie odświeża ekranu
Claude wyjaśnił wybór mniej więcej tak: kursor to sprawa przeglądarki, a nie wygląd strony, więc nie ma czego rysować od nowa. To samo zdanie działa w drugą stronę. Wszystko, co ma się pokazać na ekranie, musi żyć w stanie.
Typowy błąd agenta: Claude "optymalizuje" formularz. Pisze, że stan draft odświeża komponent przy każdej literze, więc robi z pola niekontrolowane, a treść trzyma w refie:
const draftRef = useRef("");
// ...
<span>{draftRef.current.length}/{MAX_LENGTH}</span>Litery pojawiają się w polu, bo trzyma je przeglądarka, ale licznik znaków stoi w miejscu: zmiana draftRef.current nie wywołuje renderu. Dokumentacja Reacta mówi wprost, żeby nie czytać ani nie zapisywać ref.current podczas renderowania, poza nadaniem wartości startowej: rób to w obsłudze zdarzeń albo w efektach. npm run lint pilnuje tej zasady regułą react-hooks/refs i zgłasza błąd Cannot access refs during render. Gdy go zobaczysz, poproś o powrót do stanu, a nie o wyciszenie reguły.
Przegląd kapitana
Zanim zrobisz commit, sprawdź w przeglądarce i w diffie:
- Kursor po wysłaniu. Wyślij wpis i od razu pisz dalej, bez klikania. Litery mają trafić do pola.
- Przycisk z dołu osi. Przewiń stronę w dół i kliknij "Napisz wpis": strona wraca do formularza, a kursor stoi w polu.
.currenttylko w obsłudze zdarzeń. W JSX i w ciele komponentu nie ma odczytutextareaRef.current, anpm run lintprzechodzi bez błędówreact-hooks/refs.- Bez
forwardRef. Gdy pole siedzi we własnym komponencie, w React 19 przekazujesz ref jak zwykły prop. Dokumentacja Reacta mówi, żeforwardRefnie jest już potrzebny i zostanie oznaczony jako przestarzały, a Claude czasem sięga po niego ze starszego kodu.
Następny krok
Poproś o commit z opisem w rodzaju "Fokus pola wpisu po wysłaniu i przycisk Napisz wpis". Potem druga strona notesu, czyli wartość, której nie widać:
Po wysłaniu wpisu pokaż pod formularzem w @components/Feed.tsx
komunikat "Wpis dodany", który znika po 3 sekundach. Gdy wyślę
drugi wpis wcześniej, odliczanie ma zacząć się od nowa.Komunikat trafi do stanu, bo widać go na ekranie. Numer timera z setTimeout nie jest widoczny, ale funkcja wysyłki musi go znać przy następnym wpisie, więc Claude schowa go w notesie:
setNotice("Wpis dodany");
if (noticeTimerRef.current) clearTimeout(noticeTimerRef.current);
noticeTimerRef.current = setTimeout(() => setNotice(""), 3000);noticeTimerRef powstaje obok stanu jako useRef<ReturnType<typeof setTimeout> | null>(null), czyli notes na numer timera albo pustkę. clearTimeout zatrzymuje stare odliczanie, zanim ruszy nowe, więc drugi wpis nie straci komunikatu sekundę po wysłaniu. Zmiana current nie odświeża ekranu i nie musi: ekran zmienia setNotice. W edytorze poniżej czeka formularz z tej lekcji: wyślij dwa wpisy szybko jeden po drugim i kliknij "Napisz wpis".
Pamiętaj: dziennik pokładowy zwołuje załogę, a notes w kieszeni kapitana pracuje po cichu.
Kod do tej lekcji: App.jsx
// Formularz wpisu z notesem kapitana (useRef):
// textareaRef wskazuje pole, a noticeTimerRef pamięta numer timera.
// Wyślij dwa wpisy szybko po sobie, przewiń w dół i kliknij "Napisz wpis".
import { useRef, useState } from 'react';
const MAX_LENGTH = 280;
const crewPosts = [
'Kraken widziany przy Wyspie Czaszek. Płyniemy na zachód.',
'Ster naprawiony. Kto pomoże przy żaglach?',
'Na kolację zupa rybna. Kto pierwszy, ten lepszy!',
'Mapa skarbów wysycha na pokładzie.',
'Bosman szuka ochotników do szorowania pokładu.',
'Mewy znowu ukradły sucharki.',
];
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 w obsłudze zdarzenia: kursor wraca do pola
textareaRef.current?.focus();
// Komunikat w stanie, numer timera w refie
setNotice('Wpis dodany');
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">Oś załogi</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="Co słychać na pokładzie?"
className="w-full rounded border border-gray-300 p-2"
/>
<div className="mt-2 flex items-center justify-between">
{/* Licznik liczony ze stanu draft przy każdym renderze */}
<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"
>
Wyślij
</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">Kapitan Redbeard</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"
>
Napisz wpis
</button>
</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. Co zwraca wywołanie useRef(0)?
2. Claude zamienił stan draft na useRef, żeby oszczędzić renderów: pole jest teraz niekontrolowane, a licznik znaków czyta draftRef.current. Co zobaczysz?
To 2 z 3 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w poziomie
Ułóż tokeny, które po wysłaniu wpisu przywracają kursor do pola textarea: