Kurs JavaScript i React · Moduł 9: Nowoczesne hooki React
useOptimistic - optymistyczne aktualizacje UI
W tej lekcji4
Wiadomość do bazy na Marsie leci kilka minut, ale załoga nie chce patrzeć na kręcący się wskaźnik. Chce od razu zobaczyć swoją wiadomość na liście, z dopiskiem "wysyłanie". Jeśli transmisja się nie uda, wiadomość ma zniknąć. To właśnie optymistyczna aktualizacja: zakładamy sukces, a w razie porażki wracamy do prawdziwego stanu.
Hook useOptimistic pozwala na natychmiastowe aktualizowanie interfejsu użytkownika przed otrzymaniem odpowiedzi z serwera. To kluczowe narzędzie do tworzenia responsywnych aplikacji, które dają użytkownikowi wrażenie natychmiastowej reakcji.
Podstawy useOptimistic
1. Składnia i podstawowe użycie
Hook przyjmuje prawdziwy stan i funkcję aktualizującą, a zwraca stan optymistyczny oraz funkcję, która go zmienia. Najważniejsza zasada z react.dev: tę funkcję trzeba wywołać wewnątrz Akcji, czyli w startTransition albo w akcji formularza. Poza Akcją React wypisze ostrzeżenie, a zmiana mignie i od razu zniknie. Najpierw logika listy zadań:
import { useOptimistic, useState, startTransition } from 'react';
function TodoList() {
const [todos, setTodos] = useState([
{ id: 1, text: 'Nauczyć się React', completed: false },
{ id: 2, text: 'Zbudować aplikację', completed: false }
]);
const [optimisticTodos, addOptimisticTodo] = useOptimistic(
todos,
// Funkcja aktualizująca stan optymistyczny
(currentTodos, newTodo) => [...currentTodos, newTodo]
);
async function handleAddTodo(text) {
const newTodo = {
id: Date.now(),
text,
completed: false,
pending: true // Oznaczenie jako pending
};
// Optymistyczna aktualizacja
addOptimisticTodo(newTodo);
try {
// Rzeczywiste wywołanie API
const response = await fetch('/api/todos', {
method: 'POST',
body: JSON.stringify({ text })
});
const savedTodo = await response.json();
// Aktualizacja rzeczywistego stanu
startTransition(() => {
setTodos(current => [...current, savedTodo]);
});
} catch (error) {
// W przypadku błędu stan optymistyczny zostanie automatycznie cofnięty
console.error('Błąd dodawania todo:', error);
}
}
Optymistyczne zadanie istnieje tylko tak długo, jak trwa Akcja. Gdy się zakończy, React pokazuje zwykły stan todos. Jeśli zapis się udał, setTodos dodał już prawdziwe zadanie, a jeśli nie, stan jest taki jak przedtem, więc zmiana "cofa się" sama. Aktualizację po await owijamy w kolejne startTransition, tak jak w przykładach z dokumentacji. Oto widok:
return (
<div style={{ maxWidth: '500px', margin: '0 auto', padding: '20px' }}>
<h2>Lista zadań</h2>
<form
onSubmit={(e) => {
e.preventDefault();
const text = e.target.todo.value;
if (text) {
startTransition(() => handleAddTodo(text));
e.target.reset();
}
}}
style={{ marginBottom: '20px' }}
>
<input
name="todo"
style={{
width: '70%',
padding: '8px',
marginRight: '10px',
border: '1px solid #ddd',
borderRadius: '4px'
}}
/>
<button
type="submit"
style={{
padding: '8px 16px',
backgroundColor: '#007bff',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: 'pointer'
}}
>
Dodaj
</button>
</form>
<ul style={{ listStyle: 'none', padding: 0 }}>
{optimisticTodos.map(todo => (
<li
key={todo.id}
style={{
padding: '10px',
marginBottom: '5px',
backgroundColor: todo.pending ? '#f0f8ff' : '#f8f9fa',
border: '1px solid #ddd',
borderRadius: '4px',
opacity: todo.pending ? 0.7 : 1,
transition: 'all 0.3s'
}}
>
<input
type="checkbox"
checked={todo.completed}
readOnly
style={{ marginRight: '10px' }}
/>
<span style={{
textDecoration: todo.completed ? 'line-through' : 'none'
}}>
{todo.text}
</span>
{todo.pending && (
<span style={{
marginLeft: '10px',
color: '#007bff',
fontSize: '12px'
}}>
(zapisywanie...)
</span>
)}
</li>
))}
</ul>
</div>
);
}Formularz wywołuje handleAddTodo wewnątrz startTransition, dzięki czemu optymistyczny wpis z dopiskiem "(zapisywanie...)" zostaje na ekranie aż do odpowiedzi serwera.
2. Optymistyczny przełącznik z obsługą błędów
Przycisk polubienia to klasyczny przypadek: reakcja ma być natychmiastowa, a serwer potwierdza ją w tle. Tutaj funkcja aktualizująca po prostu zwraca nową wartość:
import { useOptimistic, useState, startTransition } from 'react';
function LikeButton({ postId, initialLikes, initialIsLiked }) {
const [likes, setLikes] = useState(initialLikes);
const [isLiked, setIsLiked] = useState(initialIsLiked);
const [optimisticLikes, updateOptimisticLikes] = useOptimistic(
{ count: likes, isLiked },
(current, optimisticValue) => optimisticValue
);
async function handleLikeToggle() {
const newIsLiked = !optimisticLikes.isLiked;
const newCount = optimisticLikes.count + (newIsLiked ? 1 : -1);
// Optymistyczna aktualizacja
updateOptimisticLikes({
count: newCount,
isLiked: newIsLiked
});
try {
const response = await fetch(`/api/posts/${postId}/like`, {
method: newIsLiked ? 'POST' : 'DELETE'
});
if (!response.ok) {
throw new Error('Błąd aktualizacji');
}
const data = await response.json();
// Aktualizacja rzeczywistego stanu
setLikes(data.likes);
setIsLiked(data.isLiked);
} catch (error) {
// Stan optymistyczny zostanie automatycznie cofnięty
alert('Nie udało się zaktualizować polubienia');
}
}
return (
<button
onClick={() => startTransition(handleLikeToggle)}
style={{
display: 'flex',
alignItems: 'center',
gap: '8px',
padding: '8px 16px',
backgroundColor: optimisticLikes.isLiked ? '#dc3545' : '#fff',
color: optimisticLikes.isLiked ? '#fff' : '#dc3545',
border: '1px solid #dc3545',
borderRadius: '20px',
cursor: 'pointer',
transition: 'all 0.3s',
fontSize: '16px'
}}
>
<span>{optimisticLikes.isLiked ? 'Polubione' : 'Lubię to'}</span>
<span>{optimisticLikes.count}</span>
</button>
);
}
// Przykład użycia w komponencie posta
function Post({ post }) {
return (
<article style={{
padding: '20px',
marginBottom: '20px',
backgroundColor: '#fff',
borderRadius: '8px',
boxShadow: '0 2px 4px rgba(0,0,0,0.1)'
}}>
<h3>{post.title}</h3>
<p>{post.content}</p>
<div style={{
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center',
marginTop: '15px'
}}>
<LikeButton
postId={post.id}
initialLikes={post.likes}
initialIsLiked={post.isLiked}
/>
<span style={{ color: '#6c757d', fontSize: '14px' }}>
{new Date(post.createdAt).toLocaleDateString('pl-PL')}
</span>
</div>
</article>
);
}Kliknięcie uruchamia handleLikeToggle w startTransition. Gdy serwer zwróci błąd, blok catch pokazuje komunikat, a licznik wraca do wartości z likes, bo prawdziwy stan się nie zmienił.
3. Optymistyczne sortowanie i filtrowanie
Funkcja aktualizująca działa jak reducer: dostaje obecny stan i opis zmiany. Dzięki temu jedno wywołanie obsługuje i checkbox, i zmianę priorytetu:
import { useOptimistic, useState, startTransition } from 'react';
function OptimisticTaskList() {
const [tasks, setTasks] = useState([
{ id: 1, title: 'Zadanie 1', priority: 'low', completed: false },
{ id: 2, title: 'Zadanie 2', priority: 'high', completed: false },
{ id: 3, title: 'Zadanie 3', priority: 'medium', completed: true }
]);
const [optimisticTasks, updateOptimisticTask] = useOptimistic(
tasks,
(currentTasks, { id, updates }) =>
currentTasks.map(task =>
task.id === id ? { ...task, ...updates, updating: true } : task
)
);
async function handleTaskUpdate(taskId, updates) {
// Optymistyczna aktualizacja
updateOptimisticTask({ id: taskId, updates });
try {
const response = await fetch(`/api/tasks/${taskId}`, {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(updates)
});
const updatedTask = await response.json();
// Aktualizacja rzeczywistego stanu
setTasks(current =>
current.map(task => task.id === taskId ? updatedTask : task)
);
} catch (error) {
console.error('Błąd aktualizacji zadania:', error);
}
}
const priorityColors = {
low: '#28a745',
medium: '#ffc107',
high: '#dc3545'
};
React uruchamia tę funkcję ponownie, jeśli prawdziwy tasks zmieni się w trakcie Akcji, więc zmiana nakłada się zawsze na aktualne dane. Oto widok ze statystykami:
return (
<div style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
<h2>Zarządzanie zadaniami</h2>
<div style={{ marginBottom: '20px' }}>
<h3>Statystyki:</h3>
<div style={{ display: 'flex', gap: '20px', fontSize: '14px' }}>
<span>
Ukończone: {optimisticTasks.filter(t => t.completed).length}
</span>
<span>
W toku: {optimisticTasks.filter(t => !t.completed).length}
</span>
<span>
Wysokie priorytety: {optimisticTasks.filter(t => t.priority === 'high').length}
</span>
</div>
</div>
<div style={{ display: 'grid', gap: '10px' }}>
{optimisticTasks.map(task => (
<div
key={task.id}
style={{
padding: '15px',
backgroundColor: task.updating ? '#f0f8ff' : '#fff',
border: '1px solid #ddd',
borderRadius: '8px',
opacity: task.updating ? 0.8 : 1,
transition: 'all 0.3s'
}}
>
<div style={{
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center'
}}>
<div style={{ flex: 1 }}>
<input
type="checkbox"
checked={task.completed}
onChange={(e) =>
startTransition(() => handleTaskUpdate(task.id, { completed: e.target.checked }))
}
style={{ marginRight: '10px' }}
/>
<span style={{
textDecoration: task.completed ? 'line-through' : 'none',
color: task.completed ? '#6c757d' : '#000'
}}>
{task.title}
</span>
</div>
<select
value={task.priority}
onChange={(e) =>
startTransition(() => handleTaskUpdate(task.id, { priority: e.target.value }))
}
style={{
padding: '4px 8px',
border: `1px solid ${priorityColors[task.priority]}`,
borderRadius: '4px',
color: priorityColors[task.priority],
backgroundColor: 'transparent',
cursor: 'pointer'
}}
>
<option value="low">Niski</option>
<option value="medium">Średni</option>
<option value="high">Wysoki</option>
</select>
{task.updating && (
<span style={{
marginLeft: '10px',
color: '#007bff',
fontSize: '12px'
}}>
Zapisywanie...
</span>
)}
</div>
</div>
))}
</div>
</div>
);
}Statystyki liczymy z optimisticTasks, więc liczniki zmieniają się razem z checkboxem, bez czekania na serwer.
Zaawansowane wzorce z useOptimistic
1. Optymistyczne usuwanie z animacją
Tym razem stan optymistyczny nie usuwa elementu, tylko oznacza go flagą deleting, co daje czas na animację:
import { useOptimistic, useState, startTransition } from 'react';
function OptimisticDeleteList() {
const [items, setItems] = useState([
{ id: 1, name: 'Element 1', createdAt: new Date() },
{ id: 2, name: 'Element 2', createdAt: new Date() },
{ id: 3, name: 'Element 3', createdAt: new Date() }
]);
const [optimisticItems, removeOptimisticItem] = useOptimistic(
items,
(currentItems, removedId) =>
currentItems.map(item =>
item.id === removedId ? { ...item, deleting: true } : item
)
);
async function handleDelete(itemId) {
// Optymistyczne oznaczenie jako usuwane
removeOptimisticItem(itemId);
// Animacja przed usunięciem
await new Promise(resolve => setTimeout(resolve, 300));
try {
const response = await fetch(`/api/items/${itemId}`, {
method: 'DELETE'
});
if (!response.ok) {
throw new Error('Błąd usuwania');
}
// Rzeczywiste usunięcie ze stanu
setItems(current => current.filter(item => item.id !== itemId));
} catch (error) {
// Cofnięcie optymistycznej zmiany
alert('Nie udało się usunąć elementu');
}
}
return (
<div style={{ maxWidth: '500px', margin: '0 auto', padding: '20px' }}>
<h2>Lista z optymistycznym usuwaniem</h2>
<div style={{ display: 'grid', gap: '10px' }}>
{optimisticItems
.map(item => (
<div
key={item.id}
style={{
padding: '15px',
backgroundColor: '#fff',
border: '1px solid #ddd',
borderRadius: '8px',
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center',
opacity: item.deleting ? 0 : 1,
transform: item.deleting ? 'translateX(-100%)' : 'translateX(0)',
transition: 'all 0.3s ease-out',
overflow: 'hidden'
}}
>
<div>
<h4 style={{ margin: '0 0 5px 0' }}>{item.name}</h4>
<small style={{ color: '#6c757d' }}>
Utworzono: {item.createdAt.toLocaleString('pl-PL')}
</small>
</div>
<button
onClick={() => startTransition(() => handleDelete(item.id))}
disabled={item.deleting}
style={{
padding: '5px 10px',
backgroundColor: '#dc3545',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: item.deleting ? 'not-allowed' : 'pointer',
opacity: item.deleting ? 0.5 : 1
}}
>
{item.deleting ? 'Usuwanie...' : 'Usuń'}
</button>
</div>
))}
</div>
</div>
);
}Opóźnienie animacji jest teraz zwykłym await wewnątrz Akcji. Gdyby zapytanie siedziało w setTimeout, Akcja skończyłaby się od razu i flaga deleting zniknęłaby przed usunięciem.
2. Optymistyczna współpraca w czasie rzeczywistym
Edytor współdzielony łączy dwa stany optymistyczne z połączeniem WebSocket. Traktuj go jako szkic architektury:
import { useOptimistic, useState, useEffect, startTransition } from 'react';
function CollaborativeEditor({ documentId, userId }) {
const [content, setContent] = useState('');
const [collaborators, setCollaborators] = useState([]);
const [optimisticContent, updateOptimisticContent] = useOptimistic(
content,
(_, newContent) => newContent
);
const [optimisticCollaborators, updateOptimisticCollaborators] = useOptimistic(
collaborators,
(currentCollaborators, update) => {
if (update.type === 'cursor') {
return currentCollaborators.map(c =>
c.id === update.userId ? { ...c, cursor: update.position } : c
);
}
return currentCollaborators;
}
);
// WebSocket lub inne połączenie real-time
useEffect(() => {
const ws = new WebSocket(`ws://localhost:8080/doc/${documentId}`);
ws.onmessage = (event) => {
const data = JSON.parse(event.data);
if (data.type === 'content-update' && data.userId !== userId) {
setContent(data.content);
} else if (data.type === 'cursor-update') {
setCollaborators(data.collaborators);
}
};
return () => ws.close();
}, [documentId, userId]);
async function handleContentChange(newContent) {
// Optymistyczna aktualizacja
updateOptimisticContent(newContent);
try {
await fetch(`/api/documents/${documentId}`, {
method: 'PATCH',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ content: newContent, userId })
});
setContent(newContent);
} catch (error) {
console.error('Błąd zapisywania:', error);
}
}
function handleCursorMove(position) {
updateOptimisticCollaborators({
type: 'cursor',
userId,
position
});
// Wyślij aktualizację kursora przez WebSocket
// ws.send(JSON.stringify({ type: 'cursor', position }));
}
return (
<div style={{ maxWidth: '800px', margin: '0 auto', padding: '20px' }}>
<h2>Edytor współdzielony</h2>
<div style={{ marginBottom: '10px' }}>
<h4>Aktywni użytkownicy:</h4>
<div style={{ display: 'flex', gap: '10px' }}>
{optimisticCollaborators.map(collaborator => (
<div
key={collaborator.id}
style={{
padding: '5px 10px',
backgroundColor: collaborator.color,
color: 'white',
borderRadius: '15px',
fontSize: '12px'
}}
>
{collaborator.name}
{collaborator.cursor && (
<span style={{ marginLeft: '5px' }}>
(linia {collaborator.cursor.line})
</span>
)}
</div>
))}
</div>
</div>
<textarea
value={optimisticContent}
onChange={(e) => startTransition(() => handleContentChange(e.target.value))}
onSelect={(e) => {
const position = {
line: e.target.value.substring(0, e.target.selectionStart).split('\n').length,
column: e.target.selectionStart
};
startTransition(() => handleCursorMove(position));
}}
style={{
width: '100%',
height: '400px',
padding: '15px',
border: '1px solid #ddd',
borderRadius: '8px',
fontSize: '16px',
fontFamily: 'monospace'
}}
/>
<div style={{
marginTop: '10px',
fontSize: '12px',
color: '#6c757d'
}}>
Ostatnia synchronizacja: {new Date().toLocaleTimeString('pl-PL')}
</div>
</div>
);
}Kursor reaguje na zdarzenie onSelect, bo React nie ma zdarzenia onSelectionChange dla pola tekstowego. Dwie przestrogi: react.dev odradza sterowanie polem tekstowym przez przejścia, więc treść wpisywaną przez użytkownika lepiej trzymać w zwykłym stanie. Pozycja kursora z kolei nie czeka na serwer, dlatego zwykły useState pasuje do niej lepiej niż stan optymistyczny.
3. Wysyłanie paczkami z kolejką
Czat może wysyłać wiadomości paczkami po pięć. Najpierw kolejka i jej przetwarzanie:
import { useOptimistic, useState, useRef, startTransition } from 'react';
function BatchedUpdatesDemo() {
const [messages, setMessages] = useState([]);
const updateQueue = useRef([]);
const isProcessing = useRef(false);
const [optimisticMessages, addOptimisticMessage] = useOptimistic(
messages,
(currentMessages, newMessage) => [...currentMessages, newMessage]
);
async function processBatch() {
if (isProcessing.current || updateQueue.current.length === 0) return;
isProcessing.current = true;
const batch = updateQueue.current.splice(0, 5); // Max 5 na raz
try {
const response = await fetch('/api/messages/batch', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ messages: batch })
});
const savedMessages = await response.json();
setMessages(current => [
...current,
...savedMessages.map(msg => ({ ...msg, sent: true }))
]);
} catch (error) {
console.error('Błąd wysyłania batch:', error);
// Przywróć do kolejki
updateQueue.current.unshift(...batch);
} finally {
isProcessing.current = false;
// Przetwórz następną partię jeśli są
if (updateQueue.current.length > 0) {
setTimeout(processBatch, 100);
}
}
}
async function sendMessage(text) {
const newMessage = {
id: Date.now(),
text,
timestamp: new Date(),
sent: false,
pending: true
};
// Optymistyczna aktualizacja
addOptimisticMessage(newMessage);
// Dodaj do kolejki
updateQueue.current.push(newMessage);
// Rozpocznij przetwarzanie jeśli nie jest aktywne
await processBatch();
}
useRef trzyma kolejkę poza stanem, więc jej zmiany nie wywołują renderu. Teraz wysyłanie i widok:
return (
<div style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
<h2>Chat z batch updates</h2>
<div style={{
height: '400px',
overflowY: 'auto',
border: '1px solid #ddd',
borderRadius: '8px',
padding: '15px',
marginBottom: '15px',
backgroundColor: '#f8f9fa'
}}>
{optimisticMessages.map(message => (
<div
key={message.id}
style={{
marginBottom: '10px',
padding: '10px',
backgroundColor: message.pending ? '#e3f2fd' : '#fff',
borderRadius: '8px',
opacity: message.pending ? 0.8 : 1,
transition: 'all 0.3s'
}}
>
<div style={{ marginBottom: '5px' }}>{message.text}</div>
<div style={{
fontSize: '12px',
color: '#6c757d',
display: 'flex',
justifyContent: 'space-between'
}}>
<span>{message.timestamp.toLocaleTimeString('pl-PL')}</span>
<span>
{message.pending ? 'Wysyłanie...' : 'Wysłane'}
</span>
</div>
</div>
))}
</div>
<form
onSubmit={(e) => {
e.preventDefault();
const input = e.target.message;
if (input.value) {
startTransition(() => sendMessage(input.value));
input.value = '';
}
}}
style={{ display: 'flex', gap: '10px' }}
>
<input
name="message"
style={{
flex: 1,
padding: '10px',
border: '1px solid #ddd',
borderRadius: '4px'
}}
/>
<button
type="submit"
style={{
padding: '10px 20px',
backgroundColor: '#007bff',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: 'pointer'
}}
>
Wyślij
</button>
</form>
<div style={{
marginTop: '10px',
fontSize: '12px',
color: '#6c757d'
}}>
W kolejce: {updateQueue.current.length} |
Przetwarzanie: {isProcessing.current ? 'Tak' : 'Nie'}
</div>
</div>
);
}sendMessage czeka na processBatch, więc wiadomość zostaje optymistyczna do końca wysyłki. Uwaga: gdy paczka jest już w drodze, processBatch wraca od razu, a kolejna wiadomość może zniknąć przed wysłaniem. Licznik kolejki czyta też ref, więc nie odświeża się sam.
Praktyczne zastosowania useOptimistic
1. System komentarzy z reakcjami
Jeden reducer obsługuje trzy typy zmian: dodanie komentarza, reakcję i odpowiedź. Najpierw logika:
import { useOptimistic, useState, startTransition } from 'react';
function CommentSystem({ postId }) {
const [comments, setComments] = useState([]);
const [optimisticComments, updateOptimisticComment] = useOptimistic(
comments,
(currentComments, action) => {
switch (action.type) {
case 'add':
return [...currentComments, action.comment];
case 'react':
return currentComments.map(comment =>
comment.id === action.commentId
? {
...comment,
reactions: {
...comment.reactions,
[action.reaction]: (comment.reactions[action.reaction] || 0) + 1
},
userReacted: action.reaction
}
: comment
);
case 'reply':
return currentComments.map(comment =>
comment.id === action.parentId
? {
...comment,
replies: [...(comment.replies || []), action.reply]
}
: comment
);
default:
return currentComments;
}
}
);
async function addComment(text) {
const newComment = {
id: Date.now(),
text,
author: 'Ty',
timestamp: new Date(),
reactions: {},
replies: [],
pending: true
};
updateOptimisticComment({ type: 'add', comment: newComment });
try {
const response = await fetch(`/api/posts/${postId}/comments`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ text })
});
const savedComment = await response.json();
setComments(current => [...current, savedComment]);
} catch (error) {
console.error('Błąd dodawania komentarza:', error);
}
}
async function reactToComment(commentId, reaction) {
updateOptimisticComment({
type: 'react',
commentId,
reaction
});
try {
await fetch(`/api/comments/${commentId}/react`, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ reaction })
});
// Zaktualizuj rzeczywisty stan
const response = await fetch(`/api/posts/${postId}/comments`);
const updatedComments = await response.json();
setComments(updatedComments);
} catch (error) {
console.error('Błąd reakcji:', error);
}
}
const reactionLabels = {
like: 'Lubię',
love: 'Super',
laugh: 'Haha',
wow: 'Wow',
sad: 'Smutne'
};
Każda zmiana przechodzi przez updateOptimisticComment z polem type, tak jak akcje w useReducer. Teraz widok:
return (
<div style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
<h3>Komentarze</h3>
<form
onSubmit={(e) => {
e.preventDefault();
const text = e.target.comment.value;
if (text) {
startTransition(() => addComment(text));
e.target.reset();
}
}}
style={{ marginBottom: '20px' }}
>
<textarea
name="comment"
rows="3"
style={{
width: '100%',
padding: '10px',
border: '1px solid #ddd',
borderRadius: '4px',
marginBottom: '10px'
}}
/>
<button
type="submit"
style={{
padding: '8px 16px',
backgroundColor: '#007bff',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: 'pointer'
}}
>
Dodaj komentarz
</button>
</form>
<div style={{ display: 'grid', gap: '15px' }}>
{optimisticComments.map(comment => (
<div
key={comment.id}
style={{
padding: '15px',
backgroundColor: comment.pending ? '#f0f8ff' : '#fff',
border: '1px solid #ddd',
borderRadius: '8px',
opacity: comment.pending ? 0.8 : 1
}}
>
<div style={{ marginBottom: '10px' }}>
<strong>{comment.author}</strong>
<span style={{
marginLeft: '10px',
color: '#6c757d',
fontSize: '14px'
}}>
{comment.timestamp.toLocaleString('pl-PL')}
</span>
{comment.pending && (
<span style={{
marginLeft: '10px',
color: '#007bff',
fontSize: '12px'
}}>
(wysyłanie...)
</span>
)}
</div>
<p style={{ margin: '10px 0' }}>{comment.text}</p>
<div style={{ display: 'flex', gap: '10px' }}>
{Object.entries(reactionLabels).map(([reaction, label]) => (
<button
key={reaction}
onClick={() => startTransition(() => reactToComment(comment.id, reaction))}
style={{
padding: '4px 8px',
backgroundColor: comment.userReacted === reaction ? '#e3f2fd' : '#f8f9fa',
border: '1px solid #ddd',
borderRadius: '15px',
cursor: 'pointer',
fontSize: '14px',
display: 'flex',
alignItems: 'center',
gap: '4px'
}}
>
<span>{label}</span>
{comment.reactions[reaction] > 0 && (
<span>{comment.reactions[reaction]}</span>
)}
</button>
))}
</div>
{comment.replies && comment.replies.length > 0 && (
<div style={{
marginTop: '15px',
marginLeft: '20px',
paddingLeft: '15px',
borderLeft: '2px solid #e9ecef'
}}>
{comment.replies.map(reply => (
<div key={reply.id} style={{ marginBottom: '10px' }}>
<strong>{reply.author}:</strong> {reply.text}
</div>
))}
</div>
)}
</div>
))}
</div>
</div>
);
}Przyciski reakcji i formularz uruchamiają funkcje w startTransition, więc liczniki rosną natychmiast.
2. Drag & Drop z optymistycznym sortowaniem
Przeciąganie elementów to kolejny przypadek, w którym użytkownik nie może czekać na serwer:
import { useOptimistic, useState, startTransition } from 'react';
function DragDropList() {
const [items, setItems] = useState([
{ id: 1, text: 'Element 1', order: 0 },
{ id: 2, text: 'Element 2', order: 1 },
{ id: 3, text: 'Element 3', order: 2 },
{ id: 4, text: 'Element 4', order: 3 }
]);
const [draggedItem, setDraggedItem] = useState(null);
const [optimisticItems, reorderOptimistic] = useOptimistic(
items,
(currentItems, { fromIndex, toIndex }) => {
const newItems = [...currentItems];
const [removed] = newItems.splice(fromIndex, 1);
newItems.splice(toIndex, 0, removed);
return newItems.map((item, index) => ({ ...item, order: index }));
}
);
async function handleDrop(fromIndex, toIndex) {
if (fromIndex === toIndex) return;
// Optymistyczna aktualizacja
reorderOptimistic({ fromIndex, toIndex });
try {
const response = await fetch('/api/items/reorder', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ fromIndex, toIndex })
});
const reorderedItems = await response.json();
setItems(reorderedItems);
} catch (error) {
console.error('Błąd zmiany kolejności:', error);
}
}
return (
<div style={{ maxWidth: '400px', margin: '0 auto', padding: '20px' }}>
<h2>Lista Drag & Drop</h2>
<div style={{
border: '1px solid #ddd',
borderRadius: '8px',
overflow: 'hidden'
}}>
{optimisticItems.map((item, index) => (
<div
key={item.id}
draggable
onDragStart={() => setDraggedItem({ item, index })}
onDragOver={(e) => e.preventDefault()}
onDrop={() => {
if (draggedItem) {
startTransition(() => handleDrop(draggedItem.index, index));
setDraggedItem(null);
}
}}
style={{
padding: '15px',
backgroundColor: '#fff',
borderBottom: '1px solid #e9ecef',
cursor: 'move',
display: 'flex',
alignItems: 'center',
transition: 'all 0.3s',
opacity: draggedItem?.item.id === item.id ? 0.5 : 1
}}
>
<span style={{
marginRight: '15px',
fontSize: '20px',
color: '#6c757d'
}}>
≡
</span>
<span style={{ flex: 1 }}>{item.text}</span>
<span style={{
color: '#6c757d',
fontSize: '14px'
}}>
#{item.order + 1}
</span>
</div>
))}
</div>
<p style={{
marginTop: '15px',
fontSize: '14px',
color: '#6c757d',
textAlign: 'center'
}}>
Przeciągnij elementy, aby zmienić kolejność
</p>
</div>
);
}Nowa kolejność pojawia się od razu po upuszczeniu, a serwer tylko ją potwierdza.
Najlepsze praktyki z useOptimistic
1. Struktura danych
Oznaczaj dane optymistyczne, żeby interfejs mógł je wyróżnić:
// DOBRZE - oznaczanie stanu optymistycznego
const optimisticItem = {
...originalItem,
optimistic: true, // lub pending: true
optimisticId: Date.now() // do identyfikacji
};
// DOBRZE - zachowanie oryginalnych danych
const [optimistic, update] = useOptimistic(
realData,
(current, change) => ({
...current,
...change,
_original: current // zachowaj oryginał
})
);
// ŹLE - brak oznaczenia stanu
const badOptimistic = {
...originalItem
// Brak sposobu na odróżnienie od rzeczywistych danych
};Flaga pending lub optimistic pozwala pokazać "wysyłanie" i zablokować akcje na niepotwierdzonych elementach.
2. Obsługa błędów
Ponawianie z wykładniczym odstępem pasuje do chwilowych awarii sieci:
// Strategia retry z exponential backoff
async function optimisticUpdateWithRetry(action, maxRetries = 3) {
let lastError;
for (let i = 0; i < maxRetries; i++) {
try {
const result = await action();
return result;
} catch (error) {
lastError = error;
if (i < maxRetries - 1) {
// Exponential backoff
await new Promise(resolve =>
setTimeout(resolve, Math.pow(2, i) * 1000)
);
}
}
}
// Pokaż użytkownikowi błąd
showErrorNotification('Operacja nie powiodła się. Spróbuj ponownie.');
throw lastError;
}Pamiętaj, że stan optymistyczny trwa przez całe ponawianie, bo cała funkcja działa w jednej Akcji.
3. Wydajność
Na koniec dwa wzorce wydajnościowe:
// DOBRZE - batch updates
const [optimistic, batchUpdate] = useOptimistic(
items,
(current, updates) => {
// Przetwórz wiele aktualizacji na raz
return updates.reduce((acc, update) => {
// Zastosuj każdą aktualizację
return applyUpdate(acc, update);
}, current);
}
);
// Użycie
function handleMultipleUpdates(updates) {
batchUpdate(updates); // Jedna aktualizacja zamiast wielu
}
// DOBRZE - memoizacja ciężkich obliczeń
const processedOptimisticData = useMemo(() => {
return expensiveProcessing(optimisticData);
}, [optimisticData]);Jedno wywołanie z tablicą zmian daje jeden przebieg reducera zamiast wielu.
Hook useOptimistic to klucz do tworzenia responsywnych aplikacji, które dają użytkownikowi natychmiastową informację zwrotną. Prawidłowe używanie tego hooka może znacząco poprawić postrzeganą wydajność aplikacji.
Moja rada: najprościej jest używać useOptimistic z akcją formularza, bo wtedy React sam owija ją w przejście. W projekcie tego modułu połączysz ten hook z useActionState. Pamiętaj: optymizm na mostku trwa tylko do raportu z Marsa, potem liczy się prawdziwy stan.
Kod do tej lekcji: App.jsx
import { useState, useOptimistic, useTransition } from 'react';
// Symulacja API: opóźnione odpowiedzi serwera
function simulateAPI(action, data) {
return new Promise((resolve, reject) => {
setTimeout(() => {
// 10% szans na błąd
if (Math.random() < 0.1) {
reject(new Error(`Błąd serwera przy: ${action}`));
} else {
resolve({ success: true, data });
}
}, 1000 + Math.random() * 1500);
});
}
function MissionCard({ mission, onToggle, onDelete }) {
return (
<div style={{
padding: '14px 16px', marginBottom: '10px',
background: mission.sending
? 'rgba(0, 212, 255, 0.06)'
: mission.completed
? 'rgba(78, 205, 196, 0.08)'
: 'rgba(255, 255, 255, 0.03)',
borderRadius: '10px',
border: `1px solid ${mission.sending ? '#1a3a5c' : mission.completed ? '#2a5c3a' : '#1a2a3c'}`,
opacity: mission.sending ? 0.7 : 1,
transition: 'all 0.3s ease',
display: 'flex', alignItems: 'center', gap: '12px',
}}>
<button
onClick={() => onToggle(mission.id)}
disabled={mission.sending}
aria-pressed={mission.completed}
style={{
width: '28px', height: '28px', borderRadius: '50%',
border: `2px solid ${mission.completed ? '#4ecdc4' : '#778da9'}`,
background: mission.completed ? '#4ecdc4' : 'transparent',
cursor: mission.sending ? 'default' : 'pointer',
display: 'flex', alignItems: 'center', justifyContent: 'center',
color: '#fff', fontSize: '14px', flexShrink: 0,
}}
>
{mission.completed ? '√' : ''}
</button>
<div style={{ flex: 1 }}>
<div style={{
color: mission.completed ? '#4ecdc4' : '#e0e1dd',
textDecoration: mission.completed ? 'line-through' : 'none',
fontSize: '15px', fontWeight: 500,
}}>
{mission.name}
</div>
<div style={{ color: '#556677', fontSize: '12px', marginTop: '2px' }}>
{mission.priority}
</div>
</div>
{mission.sending && (
<span style={{ color: '#00d4ff', fontSize: '11px', fontStyle: 'italic' }}>
Synchronizacja...
</span>
)}
<button
onClick={() => onDelete(mission.id)}
disabled={mission.sending}
style={{
padding: '4px 8px', background: 'transparent',
border: '1px solid #5c1a1a', borderRadius: '4px',
color: '#ff6b6b', cursor: mission.sending ? 'default' : 'pointer',
fontSize: '12px',
}}
>
Usuń
</button>
</div>
);
}
export default function App() {
const [missions, setMissions] = useState([
{ id: 1, name: 'Zbadaj orbitę Marsa', completed: false, priority: 'Wysoki' },
{ id: 2, name: 'Napraw moduł komunikacyjny', completed: true, priority: 'Krytyczny' },
{ id: 3, name: 'Zbierz próbki z Io', completed: false, priority: 'Średni' },
{ id: 4, name: 'Skalibruj teleskop', completed: false, priority: 'Niski' },
]);
const [newMission, setNewMission] = useState('');
const [error, setError] = useState(null);
const [isPending, startTransition] = useTransition();
// useOptimistic - natychmiastowe aktualizacje UI
const [optimisticMissions, addOptimistic] = useOptimistic(
missions,
// Reduktor: (aktualny stan, zmiana optymistyczna) => nowy stan optymistyczny
(currentMissions, optimisticUpdate) => {
switch (optimisticUpdate.type) {
case 'toggle':
return currentMissions.map(m =>
m.id === optimisticUpdate.id
? { ...m, completed: !m.completed, sending: true }
: m
);
case 'add':
return [...currentMissions, { ...optimisticUpdate.mission, sending: true }];
case 'delete':
return currentMissions.map(m =>
m.id === optimisticUpdate.id ? { ...m, sending: true } : m
);
default:
return currentMissions;
}
}
);
// Każda zmiana to Akcja w startTransition: stan optymistyczny trwa, dopóki funkcja asynchroniczna się nie skończy
function handleToggle(id) {
setError(null);
startTransition(async () => {
addOptimistic({ type: 'toggle', id });
try {
await simulateAPI('toggle', { id });
// Aktualizację po await owijamy w kolejne startTransition, jak radzi react.dev
startTransition(() => {
setMissions(prev =>
prev.map(m => m.id === id ? { ...m, completed: !m.completed } : m)
);
});
} catch (err) {
// Błąd: nic nie zmieniamy, stan optymistyczny zniknie sam po zakończeniu Akcji
setError(`Nie udało się zmienić statusu misji (ID: ${id})`);
}
});
}
function handleAdd(e) {
e.preventDefault();
const name = newMission.trim();
if (!name) return;
setError(null);
setNewMission('');
const tempMission = { id: Date.now(), name, completed: false, priority: 'Średni' };
startTransition(async () => {
addOptimistic({ type: 'add', mission: tempMission });
try {
await simulateAPI('add', tempMission);
startTransition(() => {
setMissions(prev => [...prev, tempMission]);
});
} catch (err) {
setError('Nie udało się dodać misji');
}
});
}
function handleDelete(id) {
setError(null);
startTransition(async () => {
addOptimistic({ type: 'delete', id });
try {
await simulateAPI('delete', { id });
startTransition(() => {
setMissions(prev => prev.filter(m => m.id !== id));
});
} catch (err) {
setError(`Nie udało się usunąć misji (ID: ${id})`);
}
});
}
const completed = optimisticMissions.filter(m => m.completed).length;
const total = optimisticMissions.length;
return (
<div style={{
minHeight: '100vh',
background: 'linear-gradient(135deg, #0a0e27 0%, #1a1a3e 100%)',
padding: '24px', fontFamily: 'monospace',
}}>
<h1 style={{ color: '#00d4ff', textAlign: 'center', marginBottom: '4px' }}>
useOptimistic - Misje kosmiczne
</h1>
<p style={{ color: '#778da9', textAlign: 'center', marginBottom: '24px', fontSize: '13px' }}>
Zmiany widoczne natychmiast, synchronizacja w tle
</p>
<div style={{ maxWidth: '550px', margin: '0 auto' }}>
<div style={{
marginBottom: '20px', padding: '14px',
background: 'rgba(0, 212, 255, 0.06)', borderRadius: '10px',
}}>
<div style={{
display: 'flex', justifyContent: 'space-between',
marginBottom: '8px', fontSize: '13px', color: '#c0c8d0',
}}>
<span>Postęp misji {isPending && <em style={{ color: '#00d4ff' }}>(trwa synchronizacja)</em>}</span>
<span>{completed}/{total} ukończonych</span>
</div>
<div style={{
height: '8px', background: '#1a2a3c', borderRadius: '4px', overflow: 'hidden',
}}>
<div style={{
height: '100%', width: `${total > 0 ? (completed / total) * 100 : 0}%`,
background: 'linear-gradient(90deg, #00d4ff, #4ecdc4)',
borderRadius: '4px', transition: 'width 0.3s ease',
}} />
</div>
</div>
<form onSubmit={handleAdd} style={{
display: 'flex', gap: '8px', marginBottom: '20px',
}}>
<input
value={newMission}
onChange={e => setNewMission(e.target.value)}
placeholder="Nowa misja..."
style={{
flex: 1, padding: '10px 14px', background: '#0d1b2a',
border: '1px solid #1a3a5c', borderRadius: '8px',
color: '#e0e1dd', fontSize: '14px',
}}
/>
<button type="submit" style={{
padding: '10px 20px', background: '#1a3a5c',
border: 'none', borderRadius: '8px', color: '#00d4ff',
cursor: 'pointer', fontSize: '13px', whiteSpace: 'nowrap',
}}>
+ Dodaj
</button>
</form>
{error && (
<div role="alert" style={{
padding: '10px 14px', marginBottom: '12px',
background: 'rgba(255, 107, 107, 0.1)', borderRadius: '8px',
border: '1px solid #5c1a1a', color: '#ff6b6b', fontSize: '13px',
}}>
{error}
</div>
)}
{optimisticMissions.map(mission => (
<MissionCard
key={mission.id}
mission={mission}
onToggle={handleToggle}
onDelete={handleDelete}
/>
))}
<div style={{
marginTop: '20px', padding: '14px',
background: 'rgba(255, 215, 0, 0.06)', borderRadius: '10px',
fontSize: '12px', color: '#c0c8d0', lineHeight: '1.7',
}}>
<strong style={{ color: '#ffd700' }}>Jak działa useOptimistic:</strong>
<ul style={{ margin: '8px 0', paddingLeft: '18px' }}>
<li>UI aktualizuje się natychmiast (optymistycznie)</li>
<li>W tle trwa synchronizacja z serwerem (1-2,5 s)</li>
<li>Przy błędzie (10% szans) stan optymistyczny znika i wraca prawdziwy stan</li>
<li>Wskaźnik "Synchronizacja..." informuje o trwającej Akcji</li>
</ul>
</div>
</div>
</div>
);
}Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Do czego służy hook useTransition w React?
2. Co się dzieje z optymistyczną aktualizacją UI (useOptimistic), gdy żądanie do serwera zwróci błąd?
To 2 z 9 pytań do tej lekcji. Pozostałe rozwiążesz w grze.
Zadania praktyczne w grze
- Układanie w pionie
Ułóż kod komponentu, który łączy etykietę z polem przez useId:
- Układanie w pionie
Ułóż poprawną składnię użycia useTransition:
- Edytor kodu
Czat z bazą Luna wysyła wiadomości przez akcję formularza sendMessage. Łącze odpowiada po 0,6 s, a wiadomość zaczynająca się od ! udaje zakłócenia i kończy się błędem. Uzupełnij luki: ___BLANK1___ to hook Reacta 19, który tworzy stan optymistyczny z prawdziwej listy messages i funkcji dopisującej wiadomość, ___BLANK2___ to funkcja, którą pokazujesz wiadomość od razu, zanim baza odpowie, a ___BLANK3___ to lista, którą wyświetlasz w <ul>. Wysłana wiadomość ma się pojawić natychmiast z dopiskiem o wysyłaniu, po potwierdzeniu zostać bez dopisku, a przy błędzie zniknąć i zostawić komunikat.
- Układanie w pionie
Uporządkuj etapy jednego cyklu renderowania w React:
- Układanie w pionie
Uporządkuj kroki ładowania danych za pomocą hooka use() i Suspense:
- Klikanie w kolejności
Ułóż składnię hooka useCallback do stabilizacji referencji funkcji:
- Układanie w pionie
Od czego zaczynasz optymalizację wydajności? Ułóż etapy: pierwszy krok jest stały, a kolejność technik po nim zależy od tego, co pokaże pomiar.
- Układanie w poziomie
Ułóż składnię destrukturyzacji hooka useOptimistic:
- Układanie w pionie
Uporządkuj etapy pipeline optymalizacji buildu od analizy do dostarczenia:
- Edytor kodu
Analizator paczki (np. rollup-plugin-visualizer w Vite) zapisał rozmiary modułów aplikacji po kompresji. Uzupełnij raport: ___BLANK1___ to rozmiar pojedynczego modułu (pole obiektu item), który reduce dodaje do sumy, ___BLANK2___ to wyrażenie porównujące, które ustawia moduły od największego do najmniejszego, a ___BLANK3___ to warunek prawdziwy dla modułu większego niż budżet BUDGET. Raport ma pokazać łączny rozmiar 742 kB, listę od star-map (310 kB) do navigation (24 kB), a po zaznaczeniu pola tylko trzy moduły powyżej 100 kB, czyli kandydatów do wydzielenia przez lazy().
- Klikanie w kolejności
Ułóż składnię komponentu Profiler do mierzenia wydajności (atrybut id przed onRender):
- Układanie w pionie
Uporządkuj kroki diagnozowania wydajności za pomocą React Profiler:
- Edytor kodu
Galeria pokazuje zdjęcia trzech planet. Każde zdjęcie ma małą, rozmytą miniaturę widoczną od razu i pełny obraz, który pojawia się dopiero po załadowaniu. Uzupełnij komponent PlanetImage: ___BLANK1___ to wartość atrybutu loading, dzięki której przeglądarka pobierze pełny obraz dopiero, gdy zbliży się on do ekranu, ___BLANK2___ to status ustawiany po zdarzeniu load (miniatura znika, a zdjęcie staje się widoczne), a ___BLANK3___ to wywołanie, które po zdarzeniu error ustawia status 'error'. Każde zdjęcie ma własny stan, a błąd pokazuje komunikat z nazwą planety.
- Układanie w poziomie
Ułóż składnię elementu img z atrybutem lazy loading:
- Edytor kodu
Wykres TelemetryChart renderuje setki słupków, a przycisk dokłada kolejne. Zmierz jego rendery komponentem Profiler: ___BLANK1___ to trzeci parametr callbacku, czyli czas renderu w milisekundach (ta nazwa jest już użyta w ciele funkcji), ___BLANK2___ to komponent Reacta, który mierzy rendery swojego poddrzewa, a ___BLANK3___ to funkcja przekazana do jego atrybutu onRender. Po zamontowaniu w konsoli ma się pojawić wpis z fazą mount, a po kliknięciu przycisku wpis z fazą update.
- Klikanie w kolejności
Ułóż deklarację komponentu lazy-loaded z React.lazy:
- Układanie w pionie
Uporządkuj implementację lazy loading:
- Edytor kodu
Kalkulator skoku nadświetlnego liczy zużycie paliwa w wątku roboczym, żeby interfejs nie zamarzał. Wątek ma API Web Workera: postMessage wysyła dane, onmessage odbiera wynik, a terminate zatrzymuje wątek (w podglądzie funkcja createWorker go udaje). Uzupełnij luki: ___BLANK1___ to pole obiektu zdarzenia, w którym przychodzi wynik, ___BLANK2___ to metoda, którą sprzątanie efektu zatrzymuje wątek, a ___BLANK3___ to metoda, którą kliknięcie wysyła dystans do wątku. Wątek ma powstać raz po zamontowaniu, przycisk ma być zablokowany do czasu odpowiedzi, a wynik ma pojawić się na ekranie.
- Klikanie w kolejności
Uporządkuj setup Performance Observer:
- Edytor kodu
Funkcje cacheFirst, networkFirst i pickStrategy trafią do pliku sw.js i obsłużą zdarzenie fetch w Service Workerze. Pliki statyczne mają działać w strategii cache-first (najpierw kopia z cache, sieć tylko przy braku kopii), a dane z /api/ w strategii network-first (najpierw świeża odpowiedź z sieci, kopia z cache tylko bez łączności). Uzupełnij luki: ___BLANK1___ to metoda cache, która szuka zapisanej odpowiedzi, ___BLANK2___ to metoda cache, która zapisuje odpowiedź, a ___BLANK3___ to funkcja strategii, którą pickStrategy zwraca dla adresów /api/. Panel w podglądzie pozwala wyłączyć sieć i sprawdzić, skąd przychodzą odpowiedzi.
- Edytor kodu
Formularz raportu dla Centrum Kontroli korzysta z useActionState, a przycisk wysyłania jest osobnym komponentem SubmitButton, który sam ma wiedzieć, że formularz jest w trakcie wysyłki. Uzupełnij luki: ___BLANK1___ to pole zwracane przez hook, które ma wartość true w czasie wysyłki, ___BLANK2___ to hook z react-dom, który odczytuje stan formularza, w którym jest wyrenderowany komponent, ___BLANK3___ to komponent przycisku wstawiony do formularza, a ___BLANK4___ to status, który akcja zwraca dla za krótkiego raportu. Raport krótszy niż 10 znaków ma pokazać błąd, dłuższy potwierdzenie, a w czasie transmisji przycisk ma być zablokowany i zmienić napis.
Zadania po tej lekcji
- PytanieuseTransition dla niepilnych aktualizacji
- Ułóż w kolejnościSkładnia useId dla dostępności
- Ułóż w kolejnościSkładnia useTransition
- Zadanie z kodemPraktyka: Optymistyczne aktualizacje UI
- Ułóż w kolejnościCykl renderowania React
- Ułóż w kolejnościPrzepływ use() z Suspense
- PytanieuseOptimistic - rollback na błąd
- Kliknij w kolejnościSkładnia useCallback
- Ułóż w kolejnościEtapy optymalizacji wydajności
- PytanieHook use() a useContext
- PytanieConcurrent rendering w React
- Ułóż w kolejnościSkładnia useOptimistic
- PytanieuseDeferredValue a useTransition
- Ułóż w kolejnościPipeline optymalizacji budowania
- PytanieHooki React 18+
- Zadanie z kodemPraktyka: Analiza paczki (bundle)
- Kliknij w kolejnościSkładnia komponentu Profiler
- PytanieWpływ importów na rozmiar paczki
- Ułóż w kolejnościWorkflow React Profiler
- Zadanie z kodemPraktyka: Lazy loading obrazów
- Ułóż w kolejnościSkładnia lazy loading obrazu
- Zadanie z kodemPraktyka: React Profiler
- Kliknij w kolejnościSkładnia React.lazy
- Ułóż w kolejnościImplementacja lazy loading z Suspense
- Zadanie z kodemPraktyka: Web Workers
- PytanieDynamiczny import w React
- Kliknij w kolejnościKonfiguracja monitorowania wydajności
- Zadanie z kodemPraktyka: Service Worker
- PytanieAutomatic batching a setTimeout
- Zadanie z kodemPraktyka: useActionState i useFormStatus