Kurs JavaScript i React · Moduł 6: React Router
Przekazywanie stanu przez lokalizacje w międzygalaktycznej komunikacji
W tej lekcji9
W kosmicznej podróży, czasami potrzebujemy przesłać ważne dane z jednego sektora stacji kosmicznej do drugiego. W aplikacjach React wykorzystujących React Router podobnie przekazujemy stan (dane) między różnymi stronami za pomocą mechanizmu location state. Zobaczmy, jak wykorzystać ten mechanizm do usprawnienia naszej międzygalaktycznej komunikacji.
Czym jest Location State?
Location state to mechanizm w React Router, który pozwala na przekazywanie danych podczas nawigacji między różnymi ścieżkami bez konieczności używania parametrów URL, cookies, czy globalnego stanu aplikacji. Dane te nie są widoczne w URL, ale są dostępne na stronie docelowej.
Przekazywanie stanu przez Link
Najprostszym sposobem przekazania danych przez location state jest użycie komponentu Link z dodatkowym parametrem state:
import { Link } from 'react-router-dom';
function PlanetList() {
const planets = [
{ id: 1, name: 'Mars', atmosphere: 'Cienka, głównie CO2', temperature: 'Od -125°C do 20°C' },
{ id: 2, name: 'Wenus', atmosphere: 'Gęsta, głównie CO2', temperature: 'Średnio 462°C' },
{ id: 3, name: 'Tytan', atmosphere: 'Gęsta, azot i metan', temperature: 'Średnio -179°C' }
];
return (
<div className="planet-explorer">
<h1>Eksploracja Planet</h1>
<ul className="planet-list">
{planets.map(planet => (
<li key={planet.id}>
<Link
to={`/planet/${planet.id}`}
state={{ planetData: planet }}
>
Eksploruj {planet.name}
</Link>
</li>
))}
</ul>
</div>
);
}W powyższym przykładzie, kliknięcie w link przeniesie użytkownika do strony /planet/1 (dla Marsa) i jednocześnie przekaże obiekt planetData zawierający wszystkie informacje o planecie.
Odbieranie stanu w komponencie docelowym
Aby odczytać przekazany stan w komponencie docelowym, używamy hooka useLocation:
import { useParams, useLocation } from 'react-router-dom';
function PlanetDetails() {
// Pobieramy parametr z URL
const { id } = useParams();
// Pobieramy obiekt location, który zawiera przekazany stan
const location = useLocation();
// Wyciągamy dane planety z stanu lokalizacji, z fallbackiem na pusty obiekt
const { planetData } = location.state || {};
// Jeśli nie otrzymaliśmy danych planety, możemy pokazać komunikat o błędzie
// lub próbować pobrać dane na podstawie ID
if (!planetData) {
return (
<div className="error-message">
<h2>Brak danych planety</h2>
<p>Nie udało się wczytać danych dla planety o ID: {id}</p>
<Link to="/">Wróć do listy planet</Link>
</div>
);
}
return (
<div className="planet-details">
<h1>Szczegóły planety: {planetData.name}</h1>
<div className="planet-info">
<p><strong>Atmosfera:</strong> {planetData.atmosphere}</p>
<p><strong>Temperatura:</strong> {planetData.temperature}</p>
</div>
<Link to="/">Wróć do listy planet</Link>
</div>
);
}Programowe przekazywanie stanu
Możemy również przekazywać stan programowo za pomocą hooka useNavigate:
import { useNavigate } from 'react-router-dom';
function MissionControl() {
const navigate = useNavigate();
const startMission = (mission) => {
// Wykonujemy jakieś operacje przed przejściem do następnej strony
const missionData = {
...mission,
startDate: new Date().toISOString(),
commander: 'Kapitan Alex Chen',
status: 'W trakcie'
};
// Przekierowujemy do strony misji z danymi
navigate(`/mission/${mission.id}`, {
state: { missionData }
});
};
return (
<div className="mission-control">
<h1>Centrum Dowodzenia Misjami</h1>
<div className="mission-list">
<div className="mission-card">
<h3>Misja: Eksploracja Marsa</h3>
<p>Cel: Badanie próbek gleby</p>
<button onClick={() => startMission({
id: 'mars-exploration-1',
name: 'Eksploracja Marsa',
objective: 'Badanie próbek gleby'
})}>
Rozpocznij misję
</button>
</div>
<div className="mission-card">
<h3>Misja: Stacja Satelitarna</h3>
<p>Cel: Naprawa układów komunikacyjnych</p>
<button onClick={() => startMission({
id: 'satellite-repair-1',
name: 'Stacja Satelitarna',
objective: 'Naprawa układów komunikacyjnych'
})}>
Rozpocznij misję
</button>
</div>
</div>
</div>
);
}Zaawansowane przypadki użycia
1. Przekazywanie informacji o poprzedniej lokalizacji
Możemy używać location state do zapamiętania strony, z której użytkownik przybył:
function SecureArea() {
const navigate = useNavigate();
const { user } = useAuth();
useEffect(() => {
if (!user) {
// Przekierowanie do logowania z informacją o bieżącej ścieżce
navigate('/login', {
state: { from: location.pathname },
replace: true
});
}
}, [user, navigate, location]);
return (
<div className="secure-area">
<h1>Bezpieczna Sekcja Statku Kosmicznego</h1>
{/* Zawartość bezpiecznej sekcji */}
</div>
);
}
// W komponencie logowania
function Login() {
const location = useLocation();
const navigate = useNavigate();
// Pobieramy oryginalną ścieżkę, na którą użytkownik próbował się dostać
const from = location.state?.from || '/dashboard';
const handleLogin = async (credentials) => {
const success = await performLogin(credentials);
if (success) {
// Po zalogowaniu wracamy na oryginalną stronę
navigate(from, { replace: true });
}
};
// Reszta komponentu logowania...
}2. Przekazywanie danych formularza w wieloetapowym procesie
Innym zaawansowanym przypadkiem jest zachowanie danych formularza podczas nawigacji w wieloetapowym procesie:
function SpaceshipConfigStep1() {
const [config, setConfig] = useState({
name: '',
type: 'exploration',
crew: 4
});
const navigate = useNavigate();
const handleNext = () => {
// Walidacja formularza...
// Przejście do następnego kroku z danymi
navigate('/config/step2', {
state: { config }
});
};
return (
<div className="config-form">
<h2>Konfiguracja Statku Kosmicznego - Krok 1</h2>
<form onSubmit={e => { e.preventDefault(); handleNext(); }}>
<div className="form-field">
<label htmlFor="name">Nazwa statku:</label>
<input
id="name"
value={config.name}
onChange={e => setConfig({...config, name: e.target.value})}
required
/>
</div>
<div className="form-field">
<label htmlFor="type">Typ misji:</label>
<select
id="type"
value={config.type}
onChange={e => setConfig({...config, type: e.target.value})}
>
<option value="exploration">Eksploracja</option>
<option value="science">Badania naukowe</option>
<option value="mining">Wydobycie zasobów</option>
</select>
</div>
<div className="form-field">
<label htmlFor="crew">Liczba załogi:</label>
<input
id="crew"
type="number"
min="1"
max="10"
value={config.crew}
onChange={e => setConfig({...config, crew: parseInt(e.target.value)})}
required
/>
</div>
<button type="submit">Dalej</button>
</form>
</div>
);
}
function SpaceshipConfigStep2() {
const location = useLocation();
const navigate = useNavigate();
// Pobieramy konfigurację z poprzedniego kroku
const { config: prevConfig } = location.state || { config: null };
// Jeśli nie mamy konfiguracji, przekierowujemy z powrotem
useEffect(() => {
if (!prevConfig) {
navigate('/config/step1', { replace: true });
}
}, [prevConfig, navigate]);
// Inicjalizujemy stan z danymi z poprzedniego kroku
const [config, setConfig] = useState({
...prevConfig,
engines: 'ion',
fuelCapacity: 5000,
lifeSupport: 'advanced'
});
const handleFinish = () => {
// Kompletna konfiguracja z obu kroków
const finalConfig = {
...config
};
// Finalizujemy konfigurację
navigate('/config/summary', {
state: { finalConfig }
});
};
if (!prevConfig) return null; // Nie renderuj nic, dopóki przekierowanie się nie wykona
return (
<div className="config-form">
<h2>Konfiguracja Statku Kosmicznego - Krok 2</h2>
<form onSubmit={e => { e.preventDefault(); handleFinish(); }}>
{/* Drugi zestaw pól formularza */}
<div className="form-actions">
<button
type="button"
onClick={() => navigate(-1)}
>
Wstecz
</button>
<button type="submit">Zakończ</button>
</div>
</form>
</div>
);
}Funkcja replace i historia przeglądarki
W przykładach używaliśmy parametru replace: true. Jest to ważna opcja, która wpływa na zachowanie historii przeglądarki:
- Gdy
replace: false(domyślne) - dodaje nową stronę do historii. Użytkownik może wrócić do poprzedniej strony przyciskiem "Wstecz". - Gdy
replace: true- zastępuje bieżącą stronę w historii. Gdy użytkownik naciśnie przycisk "Wstecz", wróci do strony sprzed ostatniego przekierowania.
// Dodaje nową stronę do historii przeglądarki
navigate('/dashboard', { state: { data: 'example' } });
// Zastępuje bieżącą stronę w historii
navigate('/dashboard', {
state: { data: 'example' },
replace: true
});Opcja replace jest szczególnie przydatna w procesach logowania, gdzie po przekierowaniu użytkownika do strony logowania i z powrotem, nie chcemy, aby mógł wrócić do strony logowania za pomocą przycisku "Wstecz".
Ograniczenia i alternatywy
Location state ma pewne ograniczenia:
- Nie jest trwały - dane są tracone przy odświeżeniu strony
- Limitowana wielkość - nie powinniśmy przekazywać bardzo dużych obiektów
- Nie jest widoczny w URL - co może być zaletą (prywatność) lub wadą (nie można zapamiętać/udostępnić dokładnego stanu)
Alternatywne metody przekazywania danych między stronami:
Parametry URL: Dane są widoczne w adresie URL
// Przekazywanie przez URL navigate(`/planet/mars?atmosphere=thin&temperature=-60`); // Odczytywanie const { search } = useLocation(); const queryParams = new URLSearchParams(search); const atmosphere = queryParams.get('atmosphere'); // 'thin'Globalny stan aplikacji: Zarządzanie stanem za pomocą Context API, Redux, Zustand, itp.
// Zapisanie danych dispatch(setCurrentPlanet({ name: 'Mars', atmosphere: 'thin' })); navigate('/planet-details'); // Odczytanie danych const currentPlanet = useSelector(state => state.planets.current);Lokalne przechowywanie: sessionStorage, localStorage
// Zapisanie danych sessionStorage.setItem('planetData', JSON.stringify({ name: 'Mars' })); navigate('/planet-details'); // Odczytanie danych const planetData = JSON.parse(sessionStorage.getItem('planetData') || '{}');
Najlepsze praktyki
- Minimalny zakres danych: Przekazuj tylko niezbędne dane
- Walidacja danych: Zawsze sprawdzaj, czy dane istnieją przed ich użyciem
- Zapewniaj fallback: Miej plan B, gdy dane nie są dostępne
- Unikaj wrażliwych danych: Nie przekazuj poufnych informacji przez location state
- Używaj typesafe: Jeśli korzystasz z TypeScript, określaj typy dla danych w location state
Podsumowanie
Przekazywanie stanu przez lokalizacje w React Router jest jak międzygalaktyczna komunikacja - możemy wysyłać istotne dane między różnymi "stacjami" (stronami) naszej aplikacji bez konieczności zapamiętywania ich globalnie.
Ta technika jest szczególnie przydatna w przypadkach takich jak:
- Przekazywanie szczegółów obiektu na stronę szczegółową
- Zapamiętywanie oryginalnej lokalizacji przy przekierowaniach uwierzytelniania
- Zachowywanie stanu formularza w procesach wieloetapowych
- Przekazywanie wiadomości i komunikatów między stronami (np. "Operacja zakończona pomyślnie")
Wybierając między location state a innymi metodami przekazywania danych, zawsze rozważaj trwałość, widoczność i wielkość danych, aby wybrać najlepsze podejście dla konkretnego przypadku użycia.
Kod do tej lekcji: App.jsx
import React from 'react';
import { BrowserRouter, Routes, Route, Link, Navigate, useNavigate } from 'react-router-dom';
// Strona 404
function NotFoundPage() {
const navigate = useNavigate();
return (
<div className="page not-found">
<div className="error-code">404</div>
<h1>Zagubiony w kosmosie</h1>
<p>Ta strona nie istnieje w naszym wszechświecie.</p>
<div className="actions">
<button onClick={() => navigate('/')}>Wróć do domu</button>
<button onClick={() => navigate(-1)}>← Cofnij</button>
</div>
</div>
);
}
// Strona główna
function HomePage() {
return (
<div className="page">
<h1>Strona główna</h1>
<p>Witaj w centrum kontroli!</p>
</div>
);
}
// Strona profilu (przekierowanie ze starego URL)
function ProfilePage() {
return (
<div className="page">
<h1>Profil użytkownika</h1>
<p>Twoje dane profilowe.</p>
</div>
);
}
// Strona ustawień
function SettingsPage() {
return (
<div className="page">
<h1>Ustawienia</h1>
<p>Konfiguracja systemu.</p>
</div>
);
}
// Stara strona (przekierowanie)
function OldPage() {
return <Navigate to="/new-page" replace />;
}
function NewPage() {
return (
<div className="page">
<h1>Nowa strona</h1>
<p>Zostałeś przekierowany ze starej strony!</p>
</div>
);
}
function Navigation() {
return (
<nav>
<Link to="/">Home</Link>
<Link to="/profile">Profil</Link>
<Link to="/settings">Ustawienia</Link>
<Link to="/old-page">Stara strona (redirect)</Link>
<Link to="/non-existent">Nieistniejąca</Link>
</nav>
);
}
function App() {
return (
<BrowserRouter>
<div className="app">
<Navigation />
<Routes>
<Route path="/" element={<HomePage />} />
<Route path="/profile" element={<ProfilePage />} />
<Route path="/settings" element={<SettingsPage />} />
{/* Przekierowanie ze starego URL na nowy */}
<Route path="/old-page" element={<Navigate to="/new-page" replace />} />
<Route path="/new-page" element={<NewPage />} />
{/* Przekierowanie z /user na /profile */}
<Route path="/user" element={<Navigate to="/profile" />} />
<Route path="/user/:id" element={<Navigate to="/profile" />} />
{/* Catch-all route - 404 */}
<Route path="*" element={<NotFoundPage />} />
</Routes>
</div>
</BrowserRouter>
);
}
export default App;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. W jaki sposób można przekazać dane do następnej strony za pomocą komponentu Link?
2. Jakiego hooka użyjesz, aby odczytać dane przekazane przez location state?
Zadania praktyczne w grze
- Klikanie w kolejności
Ułóż składnię programowego przekazywania stanu za pomocą navigate: