Kurs JavaScript i React · Moduł 9: Nowoczesne hooki React
useTransition - nieblokujące aktualizacje UI
W tej lekcji3
Wyobraź sobie pulpit centrum kontroli misji. Operator wpisuje nazwę gwiazdy, a pod spodem filtruje się katalog dziesięciu tysięcy obiektów. Jeśli React potraktuje obie zmiany tak samo pilnie, każde naciśnięcie klawisza czeka na przerysowanie całej listy i pole tekstowe zaczyna się zacinać.
Hook useTransition, wprowadzony w React 18, pozwala oznaczyć część aktualizacji stanu jako "przejściowe" (transition). React najpierw obsługuje zmiany pilne, a render przejściowy może przerwać, gdy pojawi się coś ważniejszego.
Czego się nauczysz:
- jak rozdzielić aktualizacje na pilne i przejściowe,
- do czego służą
isPendingistartTransition, - jak
useTransitionwspółpracuje z Suspense, - kiedy transition pomaga, a kiedy szkodzi.
Podstawy useTransition
1. Składnia i podstawowe użycie
Hook zwraca parę: flagę isPending, mówiącą, że przejście trwa, oraz funkcję startTransition, do której przekazujesz zmiany stanu o niższym priorytecie. Zobacz to w wyszukiwarce:
import { useTransition, useState } from 'react';
function SearchComponent() {
const [query, setQuery] = useState('');
const [results, setResults] = useState([]);
const [isPending, startTransition] = useTransition();
const handleSearch = (searchTerm) => {
// Pilna aktualizacja - natychmiastowa
setQuery(searchTerm);
// Przejściowa aktualizacja - może być przerwana
startTransition(() => {
// Ciężkie obliczenia lub duże listy
const searchResults = performHeavySearch(searchTerm);
setResults(searchResults);
});
};
return (
<div>
<input
value={query}
onChange={(e) => handleSearch(e.target.value)}
/>
{isPending && <div>Wyszukiwanie...</div>}
<div>
{results.map(result => (
<div key={result.id}>{result.title}</div>
))}
</div>
</div>
);
}
function performHeavySearch(term) {
// Symulacja ciężkich obliczeń
const items = [];
for (let i = 0; i < 10000; i++) {
if (`Item ${i}`.toLowerCase().includes(term.toLowerCase())) {
items.push({ id: i, title: `Item ${i}` });
}
}
return items;
}Wpisany tekst trafia do setQuery od razu, więc pole reaguje natychmiast. Aktualizacja setResults jest przejściowa: jeśli operator wpisze kolejną literę, zanim lista się przerysuje, React porzuci nieaktualny render. Ważny szczegół z dokumentacji react.dev: sam callback przekazany do startTransition wykonuje się od razu i synchronicznie. Przerywalny jest render wywołany przez setResults, a nie pętla w performHeavySearch.
2. Różnica między pilnymi a przejściowymi aktualizacjami
Teraz ten sam podział na większej liście. Pole filtra to aktualizacja pilna, bo użytkownik musi widzieć swoje litery. Przefiltrowana lista może chwilę poczekać:
import { useTransition, useState } from 'react';
function ResponsiveList() {
const [filter, setFilter] = useState('');
const [allItems] = useState(() => generateItems(10000));
const [items, setItems] = useState(allItems);
const [isPending, startTransition] = useTransition();
const handleFilterChange = (newFilter) => {
// PILNA aktualizacja - input musi być responsywny
setFilter(newFilter);
// PRZEJŚCIOWA aktualizacja - może poczekać
startTransition(() => {
const filtered = allItems.filter(item =>
item.name.toLowerCase().includes(newFilter.toLowerCase())
);
setItems(filtered);
});
};
return (
<div>
<input
value={filter}
onChange={(e) => handleFilterChange(e.target.value)}
style={{
padding: '8px',
border: '1px solid #ccc',
borderRadius: '4px'
}}
/>
<div style={{ marginTop: '10px' }}>
{isPending ? (
<div style={{ color: '#666' }}>
Aktualizowanie listy...
</div>
) : (
<div>Znaleziono {items.length} elementów</div>
)}
</div>
<div style={{ height: '400px', overflow: 'auto', marginTop: '10px' }}>
{items.map(item => (
<div
key={item.id}
style={{
padding: '8px',
borderBottom: '1px solid #eee',
backgroundColor: item.id % 2 === 0 ? '#f9f9f9' : '#fff'
}}
>
<strong>{item.name}</strong> - {item.description}
</div>
))}
</div>
</div>
);
}
function generateItems(count) {
return Array.from({ length: count }, (_, i) => ({
id: i,
name: `Element ${i + 1}`,
description: `Opis elementu numer ${i + 1}`
}));
}Flaga isPending pokazuje komunikat "Aktualizowanie listy...", gdy stara lista wciąż jest na ekranie. Zwróć uwagę, że filtrujemy zawsze pełny katalog allItems, a nie wynik poprzedniego filtrowania. Gdyby filtr działał na już przefiltrowanej liście, skasowanie litery nie przywróciłoby znikniętych elementów.
3. Współpraca z Suspense
Przejścia świetnie łączą się z Suspense. Najpierw zasób, który potrafi "zawiesić" komponent. Funkcja createResource owija Promise i rzuca go, dopóki dane nie dotrą:
import { Suspense, useTransition, useState } from 'react';
// Symulacja asynchronicznego zasobu
function createResource(promise) {
let status = 'pending';
let result;
const suspender = promise.then(
(response) => {
status = 'success';
result = response;
},
(error) => {
status = 'error';
result = error;
}
);
return {
read() {
if (status === 'pending') {
throw suspender;
} else if (status === 'error') {
throw result;
} else if (status === 'success') {
return result;
}
}
};
}
Metoda read() zwraca dane albo rzuca Promise, a React łapie go w najbliższej granicy Suspense. Tu czai się pułapka: jeśli komponent tworzyłby nowy zasób przy każdym renderze, każdy render zaczynałby nowe zapytanie i nigdy by się nie zakończył. Dlatego trzymamy zasoby w prostym cache, po jednym na każdego użytkownika:
// Cache zasobów: ten sam userId = ten sam Promise
const userResources = new Map();
function getUserResource(userId) {
if (!userResources.has(userId)) {
userResources.set(userId, createResource(
fetch(`/api/users/${userId}`).then(res => res.json())
));
}
return userResources.get(userId);
}Ten sam userId daje ten sam obiekt, więc zapytanie wychodzi raz. Teraz profil może bezpiecznie czytać dane:
// Komponent wykorzystujący zasób
function UserProfile({ userId }) {
const userResource = getUserResource(userId);
const user = userResource.read();
return (
<div style={{ padding: '20px', border: '1px solid #ddd', borderRadius: '8px' }}>
<h2>{user.name}</h2>
<p>Email: {user.email}</p>
<p>ID: {user.id}</p>
</div>
);
}
Komponent wygląda na synchroniczny, bo o czekanie dba Suspense. Pozostaje lista przełączająca użytkowników w przejściu:
// Główny komponent z useTransition
function UsersList() {
const [selectedUserId, setSelectedUserId] = useState(1);
const [isPending, startTransition] = useTransition();
const users = [
{ id: 1, name: 'Anna Kowalska' },
{ id: 2, name: 'Jan Nowak' },
{ id: 3, name: 'Maria Wiśniewska' }
];
const handleUserSelect = (userId) => {
startTransition(() => {
setSelectedUserId(userId);
});
};
return (
<div style={{ display: 'flex', gap: '20px' }}>
<div style={{ width: '200px' }}>
<h3>Wybierz użytkownika:</h3>
{users.map(user => (
<button
key={user.id}
onClick={() => handleUserSelect(user.id)}
style={{
display: 'block',
width: '100%',
margin: '5px 0',
padding: '10px',
backgroundColor: selectedUserId === user.id ? '#007bff' : '#f8f9fa',
color: selectedUserId === user.id ? 'white' : 'black',
border: '1px solid #ddd',
borderRadius: '4px',
cursor: 'pointer'
}}
>
{user.name}
</button>
))}
</div>
<div style={{ flex: 1 }}>
<Suspense
fallback={
<div style={{
padding: '20px',
textAlign: 'center',
border: '1px dashed #ddd',
borderRadius: '8px'
}}>
{isPending ? 'Ładowanie nowego użytkownika...' : 'Ładowanie...'}
</div>
}
>
<UserProfile userId={selectedUserId} />
</Suspense>
</div>
</div>
);
}Bez startTransition kliknięcie innego członka załogi od razu schowałoby profil za fallbackiem. Z przejściem React dłużej pokazuje poprzedni profil, aż nowe dane będą gotowe. Samo rzucanie obietnicy z read() to uproszczony model tego, co robią biblioteki danych. W React 19 oficjalnym sposobem czytania obietnicy w Suspense jest hook use, który poznasz w jednej z kolejnych lekcji.
Zaawansowane wzorce z useTransition
1. Optymistyczne aktualizacje
Od React 19 do startTransition można przekazać funkcję asynchroniczną. Taką funkcję dokumentacja nazywa Akcją, a isPending pozostaje true aż do jej zakończenia. Najpierw logika listy zadań:
import { useTransition, useState } from 'react';
function TodoApp() {
const [todos, setTodos] = useState([
{ id: 1, text: 'Kupić mleko', completed: false },
{ id: 2, text: 'Napisać raport', completed: true }
]);
const [isPending, startTransition] = useTransition();
const addTodo = async (text) => {
const optimisticTodo = {
id: Date.now(),
text,
completed: false,
isPending: true
};
// Optymistyczna aktualizacja
setTodos(prev => [...prev, optimisticTodo]);
startTransition(async () => {
try {
// Symulacja API call
await new Promise(resolve => setTimeout(resolve, 1000));
// Aktualizacja po pomyślnym wykonaniu
setTodos(prev =>
prev.map(todo =>
todo.id === optimisticTodo.id
? { ...todo, isPending: false }
: todo
)
);
} catch (error) {
// Cofnięcie optymistycznej aktualizacji
setTodos(prev => prev.filter(todo => todo.id !== optimisticTodo.id));
alert('Błąd przy dodawaniu zadania');
}
});
};
const toggleTodo = async (id) => {
// Optymistyczna aktualizacja
setTodos(prev =>
prev.map(todo =>
todo.id === id ? { ...todo, completed: !todo.completed, isPending: true } : todo
)
);
startTransition(async () => {
try {
await new Promise(resolve => setTimeout(resolve, 500));
setTodos(prev =>
prev.map(todo =>
todo.id === id ? { ...todo, isPending: false } : todo
)
);
} catch (error) {
// Cofnięcie zmiany
setTodos(prev =>
prev.map(todo =>
todo.id === id ? { ...todo, completed: !todo.completed, isPending: false } : todo
)
);
}
});
};
Zadanie pojawia się od razu, a potwierdzenie przychodzi po sekundzie. Uwaga z react.dev: aktualizacje stanu wykonane po await nie są już oznaczone jako przejście, więc w produkcyjnym kodzie owija się je w kolejne startTransition. Hook useOptimistic, który robi to samo krócej i sam cofa zmianę, poznasz w osobnej lekcji. Oto widok, który korzysta z isPending:
return (
<div style={{ maxWidth: '500px', margin: '0 auto', padding: '20px' }}>
<h2>Lista zadań</h2>
<form
onSubmit={(e) => {
e.preventDefault();
const formData = new FormData(e.target);
const text = formData.get('text');
if (text) {
addTodo(text);
e.target.reset();
}
}}
style={{ marginBottom: '20px' }}
>
<input
name="text"
style={{ padding: '8px', marginRight: '8px', flex: 1 }}
/>
<button
type="submit"
disabled={isPending}
style={{
padding: '8px 16px',
backgroundColor: '#007bff',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: isPending ? 'not-allowed' : 'pointer'
}}
>
{isPending ? 'Dodawanie...' : 'Dodaj'}
</button>
</form>
<ul style={{ listStyle: 'none', padding: 0 }}>
{todos.map(todo => (
<li
key={todo.id}
style={{
display: 'flex',
alignItems: 'center',
padding: '10px',
marginBottom: '5px',
backgroundColor: '#f8f9fa',
borderRadius: '4px',
opacity: todo.isPending ? 0.6 : 1
}}
>
<input
type="checkbox"
checked={todo.completed}
onChange={() => toggleTodo(todo.id)}
disabled={todo.isPending}
style={{ marginRight: '10px' }}
/>
<span
style={{
textDecoration: todo.completed ? 'line-through' : 'none',
flex: 1
}}
>
{todo.text}
</span>
{todo.isPending && (
<span style={{ color: '#666', fontSize: '12px' }}>
Aktualizowanie...
</span>
)}
</li>
))}
</ul>
</div>
);
}Przycisk "Dodaj" jest zablokowany przez cały czas trwania Akcji, a elementy w trakcie zapisu dostają obniżoną przezroczystość.
2. Debouncing z useTransition
Transition nie zastępuje debouncingu, tylko go uzupełnia. Najpierw stan i dwa efekty: jeden opóźnia zapytanie o 300 ms, drugi uruchamia wyszukiwanie w przejściu:
import { useTransition, useState, useEffect } from 'react';
function SearchWithDebouncing() {
const [query, setQuery] = useState('');
const [debouncedQuery, setDebouncedQuery] = useState('');
const [results, setResults] = useState([]);
const [isPending, startTransition] = useTransition();
// Debouncing input
useEffect(() => {
const timer = setTimeout(() => {
setDebouncedQuery(query);
}, 300);
return () => clearTimeout(timer);
}, [query]);
// Wyszukiwanie po zmianie debounced query
useEffect(() => {
if (debouncedQuery) {
startTransition(() => {
const searchResults = performSearch(debouncedQuery);
setResults(searchResults);
});
} else {
setResults([]);
}
}, [debouncedQuery]);
Debouncing ogranicza liczbę wyszukiwań, a transition chroni pisanie przed ciężkim renderem. Teraz interfejs:
return (
<div style={{ maxWidth: '600px', margin: '0 auto', padding: '20px' }}>
<h2>Wyszukiwarka z debouncing</h2>
<div style={{ position: 'relative', marginBottom: '20px' }}>
<input
value={query}
onChange={(e) => setQuery(e.target.value)}
style={{
width: '100%',
padding: '12px',
fontSize: '16px',
border: '2px solid #ddd',
borderRadius: '8px',
outline: 'none'
}}
/>
{isPending && (
<div style={{
position: 'absolute',
right: '10px',
top: '50%',
transform: 'translateY(-50%)',
color: '#666'
}}>
Wyszukiwanie...
</div>
)}
</div>
<div>
<p style={{ color: '#666', margin: '10px 0' }}>
Znaleziono {results.length} wyników
{debouncedQuery && ` dla "${debouncedQuery}"`}
</p>
<div style={{ maxHeight: '400px', overflowY: 'auto' }}>
{results.map(result => (
<div
key={result.id}
style={{
padding: '12px',
marginBottom: '8px',
backgroundColor: '#f8f9fa',
border: '1px solid #e9ecef',
borderRadius: '6px'
}}
>
<h4 style={{ margin: '0 0 5px 0', color: '#007bff' }}>
{highlightMatch(result.title, debouncedQuery)}
</h4>
<p style={{ margin: 0, color: '#666', fontSize: '14px' }}>
{highlightMatch(result.description, debouncedQuery)}
</p>
</div>
))}
</div>
</div>
</div>
);
}
Pole nadal czyta query, a wyniki czytają debouncedQuery, więc input i lista się nie blokują. Na koniec funkcje pomocnicze:
function performSearch(query) {
const items = [
{ id: 1, title: 'React Hooks', description: 'Nowoczesny sposób na zarządzanie stanem w React' },
{ id: 2, title: 'JavaScript ES6+', description: 'Najnowsze funkcje JavaScript' },
{ id: 3, title: 'TypeScript Guide', description: 'Kompletny przewodnik po TypeScript' },
{ id: 4, title: 'Node.js Backend', description: 'Tworzenie serwerów z Node.js' },
{ id: 5, title: 'CSS Grid Layout', description: 'Zaawansowane układy CSS' }
];
return items.filter(item =>
item.title.toLowerCase().includes(query.toLowerCase()) ||
item.description.toLowerCase().includes(query.toLowerCase())
);
}
function highlightMatch(text, query) {
if (!query) return text;
const regex = new RegExp(`(${query})`, 'gi');
const parts = text.split(regex);
return parts.map((part, index) =>
part.toLowerCase() === query.toLowerCase() ? (
<mark key={index} style={{ backgroundColor: '#ffeb3b', padding: '2px' }}>
{part}
</mark>
) : part
);
}Funkcja highlightMatch buduje wyrażenie regularne z tekstu użytkownika, więc w prawdziwej aplikacji zabezpiecz najpierw znaki specjalne, np. nawiasy.
3. Koordynacja kilku przejść
Jeden komponent może mieć kilka niezależnych przejść. Każde wywołanie useTransition daje osobną flagę isPending, więc wiesz, która część pulpitu jeszcze pracuje:
import { useTransition, useState } from 'react';
function MultipleTransitionsDemo() {
const [activeTab, setActiveTab] = useState('users');
const [filter, setFilter] = useState('');
const [sortBy, setSortBy] = useState('name');
const [tabPending, startTabTransition] = useTransition();
const [filterPending, startFilterTransition] = useTransition();
const [sortPending, startSortTransition] = useTransition();
const data = {
users: [
{ id: 1, name: 'Anna Kowalska', email: 'anna@example.com', role: 'Admin' },
{ id: 2, name: 'Jan Nowak', email: 'jan@example.com', role: 'User' },
{ id: 3, name: 'Maria Wiśniewska', email: 'maria@example.com', role: 'Editor' }
],
products: [
{ id: 1, name: 'Laptop', price: 2500, category: 'Electronics' },
{ id: 2, name: 'Książka', price: 45, category: 'Books' },
{ id: 3, name: 'Słuchawki', price: 150, category: 'Electronics' }
]
};
const handleTabChange = (tab) => {
startTabTransition(() => {
setActiveTab(tab);
setFilter(''); // Reset filter when changing tabs
});
};
const handleFilterChange = (newFilter) => {
setFilter(newFilter); // Immediate update for input
startFilterTransition(() => {
// Any heavy filtering logic would go here
});
};
const handleSortChange = (newSort) => {
startSortTransition(() => {
setSortBy(newSort);
});
};
const filteredAndSortedData = data[activeTab]
.filter(item =>
Object.values(item).some(value =>
value.toString().toLowerCase().includes(filter.toLowerCase())
)
)
.sort((a, b) => {
if (sortBy === 'name') return a.name.localeCompare(b.name);
if (sortBy === 'price') return (a.price || 0) - (b.price || 0);
return 0;
});
const isPending = tabPending || filterPending || sortPending;
Zakładki i sortowanie idą przez przejścia, a setFilter jest pilny, bo steruje polem tekstowym. Puste startFilterTransition to tylko miejsce na przyszłą ciężką logikę. Dokumentacja dodaje, że React obecnie łączy kilka trwających przejść w jedną partię. Oto widok:
return (
<div style={{ maxWidth: '800px', margin: '0 auto', padding: '20px' }}>
<h2>Multiple Transitions Demo</h2>
{/* Tab Navigation */}
<div style={{ marginBottom: '20px', borderBottom: '1px solid #ddd' }}>
{['users', 'products'].map(tab => (
<button
key={tab}
onClick={() => handleTabChange(tab)}
disabled={tabPending}
style={{
padding: '10px 20px',
marginRight: '10px',
backgroundColor: activeTab === tab ? '#007bff' : 'transparent',
color: activeTab === tab ? 'white' : '#007bff',
border: `2px solid ${activeTab === tab ? '#007bff' : '#ddd'}`,
borderBottom: 'none',
borderRadius: '8px 8px 0 0',
cursor: tabPending ? 'not-allowed' : 'pointer',
opacity: tabPending ? 0.6 : 1
}}
>
{tab.charAt(0).toUpperCase() + tab.slice(1)}
{tabPending && ' ...'}
</button>
))}
</div>
{/* Controls */}
<div style={{
display: 'flex',
gap: '15px',
marginBottom: '20px',
alignItems: 'center'
}}>
<input
value={filter}
onChange={(e) => handleFilterChange(e.target.value)}
style={{
padding: '8px',
border: '1px solid #ddd',
borderRadius: '4px',
flex: 1
}}
/>
<select
value={sortBy}
onChange={(e) => handleSortChange(e.target.value)}
style={{
padding: '8px',
border: '1px solid #ddd',
borderRadius: '4px'
}}
>
<option value="name">Sortuj po nazwie</option>
{activeTab === 'products' && <option value="price">Sortuj po cenie</option>}
</select>
{isPending && (
<div style={{ color: '#666', fontSize: '14px' }}>
Aktualizowanie...
</div>
)}
</div>
{/* Data Display */}
<div style={{
minHeight: '200px',
opacity: isPending ? 0.7 : 1,
transition: 'opacity 0.2s'
}}>
{filteredAndSortedData.length === 0 ? (
<div style={{
textAlign: 'center',
color: '#666',
padding: '40px'
}}>
Brak wyników
</div>
) : (
<div style={{ display: 'grid', gap: '10px' }}>
{filteredAndSortedData.map(item => (
<div
key={item.id}
style={{
padding: '15px',
backgroundColor: '#f8f9fa',
border: '1px solid #e9ecef',
borderRadius: '6px'
}}
>
<h4 style={{ margin: '0 0 5px 0' }}>{item.name}</h4>
{activeTab === 'users' ? (
<div>
<p style={{ margin: '2px 0', color: '#666' }}>
{item.email}
</p>
<p style={{ margin: '2px 0', color: '#666' }}>
{item.role}
</p>
</div>
) : (
<div>
<p style={{ margin: '2px 0', color: '#666' }}>
{item.price} zł
</p>
<p style={{ margin: '2px 0', color: '#666' }}>
{item.category}
</p>
</div>
)}
</div>
))}
</div>
)}
</div>
</div>
);
}Wspólna flaga isPending przyciemnia dane, a przyciski zakładek reagują tylko na tabPending, więc każda część pulpitu zna własny stan przejścia.
Najlepsze praktyki z useTransition
1. Kiedy używać useTransition
- Duże listy danych - filtrowanie, sortowanie
- Ciężkie obliczenia - które mogą zablokować UI
- Nawigacja - przełączanie między widokami
- Optymistyczne aktualizacje - przed potwierdzeniem z serwera
2. Czego unikać
- Nie używaj dla krytycznych aktualizacji (input values, focus management)
- Nie nadużywaj - zbyt wiele transitions może pogorszyć wydajność
- Uważaj na race conditions między różnymi transitions
Moja rada: zacznij od zwykłego stanu, a po useTransition sięgaj dopiero wtedy, gdy zmierzysz, że render blokuje wpisywanie. W tym module poznasz też useDeferredValue, bliźniaczy hook na sytuacje, w których nie kontrolujesz miejsca aktualizacji stanu.
useTransition to potężne narzędzie do utrzymania responsywności aplikacji React. Pozwala na inteligentne zarządzanie priorytetami aktualizacji, dzięki czemu użytkownik zawsze ma wrażenie płynnego działania interfejsu.
Pamiętaj: startTransition to komunikat dla kontroli misji, że ten manewr może poczekać, gdy pilot właśnie steruje statkiem.
Kod do tej lekcji: App.jsx
import { useTransition, useState } from 'react';
// Symulacja ciężkich obliczeń
function generateItems(count, filter = '') {
const items = [];
for (let i = 0; i < count; i++) {
const name = `Element ${i + 1}`;
if (filter === '' || name.toLowerCase().includes(filter.toLowerCase())) {
items.push({
id: i,
name,
description: `Opis dla elementu numer ${i + 1}`,
price: Math.floor(Math.random() * 1000) + 50
});
}
}
return items;
}
function SearchDemo() {
const [query, setQuery] = useState('');
const [results, setResults] = useState(() => generateItems(5000));
const [isPending, startTransition] = useTransition();
const handleSearch = (searchTerm) => {
// PILNA aktualizacja - input musi być responsywny
setQuery(searchTerm);
// PRZEJŚCIOWA aktualizacja - może być przerwana
startTransition(() => {
const filtered = generateItems(5000, searchTerm);
setResults(filtered);
});
};
return (
<div style={{ padding: '20px', maxWidth: '800px', margin: '0 auto' }}>
<h2>useTransition Demo - Responsywne wyszukiwanie</h2>
<div style={{ marginBottom: '20px' }}>
<input
value={query}
onChange={(e) => handleSearch(e.target.value)}
placeholder="Wpisz numer elementu (np. 100)..."
style={{
width: '100%',
padding: '12px',
fontSize: '16px',
border: '2px solid #ddd',
borderRadius: '8px',
outline: 'none',
boxSizing: 'border-box'
}}
/>
<div style={{
marginTop: '10px',
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center',
fontSize: '14px',
color: '#666'
}}>
<span>
{isPending ? (
<span style={{ color: '#007bff' }}>
Filtrowanie {query ? `"${query}"` : 'wszystkich elementów'}...
</span>
) : (
`Znaleziono ${results.length} elementów`
)}
</span>
<span style={{ fontSize: '12px' }}>
Spróbuj szybko pisać - input pozostaje responsywny!
</span>
</div>
</div>
<div style={{
height: '400px',
overflow: 'auto',
border: '1px solid #ddd',
borderRadius: '8px',
backgroundColor: '#f9f9f9'
}}>
{results.length === 0 ? (
<div style={{
padding: '40px',
textAlign: 'center',
color: '#666'
}}>
Brak wyników dla "{query}"
</div>
) : (
results.map(item => (
<div
key={item.id}
style={{
padding: '12px',
borderBottom: '1px solid #eee',
backgroundColor: item.id % 2 === 0 ? '#fff' : '#f9f9f9',
display: 'flex',
justifyContent: 'space-between',
alignItems: 'center'
}}
>
<div>
<div style={{ fontWeight: 'bold', color: '#333' }}>
{item.name}
</div>
<div style={{ fontSize: '14px', color: '#666' }}>
{item.description}
</div>
</div>
<div style={{
fontWeight: 'bold',
color: '#007bff',
fontSize: '16px'
}}>
{item.price} zł
</div>
</div>
))
)}
</div>
<div style={{
marginTop: '20px',
padding: '15px',
backgroundColor: '#e3f2fd',
borderRadius: '8px',
fontSize: '14px'
}}>
<strong>Co obserwować:</strong>
<ul style={{ margin: '10px 0', paddingLeft: '20px' }}>
<li>Input jest zawsze responsywny (pilna aktualizacja)</li>
<li>Lista może się aktualizować z opóźnieniem (przejściowa aktualizacja)</li>
<li>Podczas filtrowania pojawia się wskaźnik "Filtrowanie..."</li>
<li>React może przerwać renderowanie listy dla nowych wpisów</li>
</ul>
</div>
</div>
);
}
function TodoDemo() {
const [todos, setTodos] = useState([
{ id: 1, text: 'Kupić mleko', completed: false, isPending: false },
{ id: 2, text: 'Napisać raport', completed: true, isPending: false }
]);
const [isPending, startTransition] = useTransition();
const addTodo = async (text) => {
const newTodo = {
id: Date.now(),
text,
completed: false,
isPending: true
};
// Optymistyczna aktualizacja - natychmiast dodajemy todo
setTodos(prev => [...prev, newTodo]);
startTransition(async () => {
try {
// Symulacja API call
await new Promise(resolve => setTimeout(resolve, 1500));
// Aktualizacja po "pomyślnym" wykonaniu
setTodos(prev =>
prev.map(todo =>
todo.id === newTodo.id
? { ...todo, isPending: false }
: todo
)
);
} catch (error) {
// W przypadku błędu - usuń optymistyczne todo
setTodos(prev => prev.filter(todo => todo.id !== newTodo.id));
alert('Błąd przy dodawaniu zadania!');
}
});
};
const toggleTodo = async (id) => {
// Optymistyczna aktualizacja
setTodos(prev =>
prev.map(todo =>
todo.id === id
? { ...todo, completed: !todo.completed, isPending: true }
: todo
)
);
startTransition(async () => {
try {
await new Promise(resolve => setTimeout(resolve, 800));
setTodos(prev =>
prev.map(todo =>
todo.id === id ? { ...todo, isPending: false } : todo
)
);
} catch (error) {
// Cofnij zmianę w przypadku błędu
setTodos(prev =>
prev.map(todo =>
todo.id === id
? { ...todo, completed: !todo.completed, isPending: false }
: todo
)
);
}
});
};
return (
<div style={{ padding: '20px', maxWidth: '500px', margin: '0 auto' }}>
<h2>Optymistyczne aktualizacje z useTransition</h2>
<form
onSubmit={(e) => {
e.preventDefault();
const formData = new FormData(e.target);
const text = formData.get('text');
if (text) {
addTodo(text);
e.target.reset();
}
}}
style={{ marginBottom: '20px', display: 'flex', gap: '10px' }}
>
<input
name="text"
placeholder="Nowe zadanie..."
style={{
flex: 1,
padding: '10px',
border: '1px solid #ddd',
borderRadius: '4px'
}}
/>
<button
type="submit"
disabled={isPending}
style={{
padding: '10px 20px',
backgroundColor: isPending ? '#ccc' : '#007bff',
color: 'white',
border: 'none',
borderRadius: '4px',
cursor: isPending ? 'not-allowed' : 'pointer',
whiteSpace: 'nowrap'
}}
>
{isPending ? 'Dodawanie...' : 'Dodaj'}
</button>
</form>
<ul style={{ listStyle: 'none', padding: 0, margin: 0 }}>
{todos.map(todo => (
<li
key={todo.id}
style={{
display: 'flex',
alignItems: 'center',
padding: '12px',
marginBottom: '8px',
backgroundColor: '#f8f9fa',
borderRadius: '6px',
border: '1px solid #e9ecef',
opacity: todo.isPending ? 0.7 : 1,
transition: 'opacity 0.2s'
}}
>
<input
type="checkbox"
checked={todo.completed}
onChange={() => toggleTodo(todo.id)}
disabled={todo.isPending}
style={{ marginRight: '12px', transform: 'scale(1.2)' }}
/>
<span
style={{
flex: 1,
textDecoration: todo.completed ? 'line-through' : 'none',
color: todo.completed ? '#666' : '#333',
fontSize: '16px'
}}
>
{todo.text}
</span>
{todo.isPending && (
<span style={{
color: '#007bff',
fontSize: '12px',
fontStyle: 'italic'
}}>
Synchronizacja...
</span>
)}
</li>
))}
</ul>
<div style={{
marginTop: '20px',
padding: '15px',
backgroundColor: '#fff3cd',
borderRadius: '8px',
fontSize: '14px'
}}>
<strong>Optymistyczne aktualizacje:</strong>
<ul style={{ margin: '10px 0', paddingLeft: '20px' }}>
<li>Zmiany są widoczne natychmiast</li>
<li>W tle synchronizacja z "serwerem"</li>
<li>Wskaźniki ładowania dla długich operacji</li>
<li>Rollback w przypadku błędów</li>
</ul>
</div>
</div>
);
}
export default function App() {
const [activeDemo, setActiveDemo] = useState('search');
return (
<div style={{ minHeight: '100vh', backgroundColor: '#f5f5f5' }}>
<nav style={{
backgroundColor: '#fff',
padding: '10px 0',
borderBottom: '1px solid #ddd',
marginBottom: '20px'
}}>
<div style={{
maxWidth: '800px',
margin: '0 auto',
display: 'flex',
gap: '10px',
padding: '0 20px'
}}>
<button
onClick={() => setActiveDemo('search')}
style={{
padding: '10px 20px',
backgroundColor: activeDemo === 'search' ? '#007bff' : '#f8f9fa',
color: activeDemo === 'search' ? 'white' : '#333',
border: '1px solid #ddd',
borderRadius: '4px',
cursor: 'pointer'
}}
>
Wyszukiwanie
</button>
<button
onClick={() => setActiveDemo('todos')}
style={{
padding: '10px 20px',
backgroundColor: activeDemo === 'todos' ? '#007bff' : '#f8f9fa',
color: activeDemo === 'todos' ? 'white' : '#333',
border: '1px solid #ddd',
borderRadius: '4px',
cursor: 'pointer'
}}
>
Lista zadań
</button>
</div>
</nav>
{activeDemo === 'search' ? <SearchDemo /> : <TodoDemo />}
</div>
);
}Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?