BAB 7: Navigasi dan Routing
Rute berbasis berkas dengan Expo Router: stack, tab, grup, rute dinamis, parameter, modal, rute terlindungi, dan menjaga data tetap segar saat layar dibuka kembali.
Sampai bab ini, aplikasi contoh hanya punya 2 layar. Aplikasi nyata punya tab, halaman detail, layar pengaturan, dan alur masuk yang harus dilindungi. Semua itu perlu struktur navigasi yang jelas.
Expo Router memakai pendekatan berbasis berkas: setiap berkas di dalam folder app menjadi rute, dan nama folder menentukan susunan navigasinya. Tidak ada berkas konfigurasi rute terpisah yang harus dijaga sinkron dengan folder layar.
Rute berasal dari nama berkas
| Berkas | Rute |
|---|---|
app/index.tsx | / |
app/tentang.tsx | /tentang |
app/catatan/[id].tsx | /catatan/123 |
app/(tabs)/index.tsx | / di dalam grup tab |
app/pengaturan/notifikasi.tsx | /pengaturan/notifikasi |
Tanda kurung pada nama folder, seperti (tabs), berarti grup. Grup tidak menambah segmen pada URL, tapi bisa punya layout sendiri. Ini cara mengelompokkan layar yang berbagi navigasi tanpa mengubah alamat.
Segmen dalam kurung siku, seperti [id], adalah parameter dinamis. Nilainya dibaca dari URL, bukan dari prop.
Stack dan susunan layar
app/_layout.tsx menentukan kerangka untuk semua rute di dalam folder itu.
// app/_layout.tsx
import { Stack } from "expo-router";
import { SafeAreaProvider } from "react-native-safe-area-context";
import { Provider } from "react-redux";
import { store } from "../store";
export default function KerangkaAkar() {
return (
<Provider store={store}>
<SafeAreaProvider>
<Stack screenOptions={{ headerTitleAlign: "center" }}>
<Stack.Screen name="(tabs)" options={{ headerShown: false }} />
<Stack.Screen name="catatan/[id]" options={{ title: "Detail Catatan" }} />
<Stack.Screen name="tambah" options={{ title: "Catatan Baru", presentation: "modal" }} />
</Stack>
</SafeAreaProvider>
</Provider>
);
}
Layar yang tidak disebutkan tetap terdaftar. Menyebutkannya di layout hanya diperlukan ketika kamu ingin mengubah opsinya, seperti menyembunyikan header atau menjadikannya modal.
Tab di dalam stack
Pola yang paling sering dipakai: stack di lapisan luar, tab di dalamnya.
app/
_layout.tsx stack akar
(tabs)/
_layout.tsx tab
index.tsx beranda
catatan.tsx daftar catatan
pengaturan.tsx pengaturan
catatan/[id].tsx detail, dibuka di atas tab
// app/(tabs)/_layout.tsx
import { Tabs } from "expo-router";
import { Text } from "react-native";
export default function KerangkaTab() {
return (
<Tabs screenOptions={{ tabBarActiveTintColor: "#6366f1" }}>
<Tabs.Screen
name="index"
options={{ title: "Beranda", tabBarIcon: ({ color }) => <Text style={{ color }}>●</Text> }}
/>
<Tabs.Screen
name="catatan"
options={{ title: "Catatan", tabBarIcon: ({ color }) => <Text style={{ color }}>▣</Text> }}
/>
<Tabs.Screen
name="pengaturan"
options={{ title: "Pengaturan", tabBarIcon: ({ color }) => <Text style={{ color }}>⚙</Text> }}
/>
</Tabs>
);
}
Karena detail catatan berada di luar grup (tabs), halaman detail terbuka menutupi bilah tab. Ini perilaku yang diharapkan pada aplikasi mobile: pengguna masuk ke detail, lalu kembali ke daftar dengan tombol kembali.
Berpindah layar
3 cara yang tersedia, dengan perbedaan yang perlu dipahami.
import { Link, router } from "expo-router";
// deklaratif, cocok untuk tautan di dalam teks atau tombol sederhana
<Link href="/catatan/123">Buka catatan</Link>
// imperatif, cocok ketika perpindahan terjadi setelah logika tertentu
router.push("/catatan/123");
// mengganti layar saat ini, bukan menumpuk di atasnya
router.replace("/beranda");
| Perintah | Efek pada riwayat |
|---|---|
router.push | menambah layar baru, tombol kembali tersedia |
router.replace | mengganti layar sekarang, riwayat layar itu hilang |
router.back | kembali satu layar |
router.dismiss | menutup modal |
replace dipakai setelah login berhasil, supaya pengguna tidak bisa kembali ke layar masuk dengan tombol kembali. dismiss dipakai untuk menutup modal setelah formulir disimpan.
Sebelum memanggil back, periksa ketersediaannya. Aplikasi yang dibuka langsung dari tautan dalam tidak punya riwayat sebelumnya.
if (router.canGoBack()) {
router.back();
} else {
router.replace("/");
}
Rute dinamis dan parameter
Parameter dari segmen dinamis dibaca dengan useLocalSearchParams. Bedanya dengan useGlobalSearchParams: yang pertama mengikuti layar yang sedang fokus, yang kedua mengikuti URL secara keseluruhan.
// app/catatan/[id].tsx
import { useLocalSearchParams } from "expo-router";
import { Text, View } from "react-native";
export default function DetailCatatan() {
const { id, sumber } = useLocalSearchParams<{ id: string; sumber?: string }>();
return (
<View style={{ padding: 16 }}>
<Text>ID catatan: {id}</Text>
<Text>Sumber: {sumber ?? "langsung"}</Text>
</View>
);
}
Parameter tambahan yang bukan bagian dari rute tetap bisa dikirim sebagai query string: /catatan/123?sumber=notifikasi. Keduanya diterima oleh hook yang sama.
Satu perilaku yang perlu diketahui: ketika parameter rute berubah, komponen di-mount ulang. Ini berarti state lokal di layar itu hilang. Kalau kamu ingin mempertahankan state antar id, simpan di luar komponen atau gunakan router.setParams untuk mengubah query tanpa berpindah rute.
Modal dan layar yang muncul dari bawah
Modal cocok untuk formulir singkat yang tidak perlu mengubah konteks pengguna.
<Stack.Screen name="tambah" options={{ presentation: "modal" }} />
Untuk rute yang bisa dibuka langsung dari tautan dalam, tambahkan anchor supaya layar di belakang modal tidak hilang:
// app/_layout.tsx
export const unstable_settings = { anchor: "index" };
Tanpa anchor, membuka /tambah dari tautan luar akan menampilkan modal tanpa layar di belakangnya, dan pengguna tidak punya jalan kembali.
Rute yang dilindungi
Layar yang membutuhkan sesi harus dijaga di layout, bukan hanya disembunyikan tombolnya.
// app/(app)/_layout.tsx
import { Redirect, Stack } from "expo-router";
import { Text } from "react-native";
import { useSesi } from "../../context/SesiContext";
export default function KerangkaPrivat() {
const { sesi, memuat } = useSesi();
if (memuat) return <Text>Memuat...</Text>;
if (!sesi) return <Redirect href="/masuk" />;
return <Stack />;
}
Untuk pembatasan yang lebih rapi, Stack.Protected memberi penjaga per layar. Ketika penjaga bernilai salah, pengguna diarahkan ke rute jangkar, dan riwayat layar itu dibersihkan saat status berubah.
<Stack>
<Stack.Protected guard={!sudahMasuk}>
<Stack.Screen name="masuk" />
</Stack.Protected>
<Stack.Protected guard={sudahMasuk} redirectTo="/masuk">
<Stack.Screen name="akun" />
</Stack.Protected>
</Stack>
Menjaga di layout lebih aman daripada menyembunyikan tombol, karena rute tetap bisa diakses lewat tautan dalam.
Menjaga data tetap segar saat layar dibuka
Layar daftar yang dibuka kembali setelah pengguna menambah data perlu memuat ulang. useFocusEffect menjalankan efek setiap kali layar menjadi fokus, bukan hanya saat pertama dipasang.
import { useCallback } from "react";
import { useFocusEffect } from "expo-router";
import { useAppDispatch } from "../store/hooks";
import { muatCatatan } from "../store/catatanSlice";
export function useMuatSaatFokus() {
const dispatch = useAppDispatch();
useFocusEffect(
useCallback(() => {
dispatch(muatCatatan());
}, [dispatch]),
);
}
Callback harus dibungkus useCallback, kalau tidak efek akan berjalan pada setiap render dan memicu permintaan berulang.
Deep link
Setiap rute sudah punya alamat, dan alamat itu bisa dibuka dari luar aplikasi. Yang perlu disiapkan hanya skema di konfigurasi aplikasi:
{
"expo": {
"scheme": "catatanharian"
}
}
Setelah itu, catatanharian://catatan/123 membuka layar detail. Untuk tautan https yang membuka aplikasi, diperlukan konfigurasi domain di apple-app-site-association dan assetlinks.json, dan itu dibahas di dokumentasi Expo serta panduan masing-masing platform.
Uji deep link di emulator:
npx uri-scheme open "catatanharian://catatan/123" --android
Tombol kembali di Android
Android punya tombol kembali sistem, iOS tidak. React Navigation di dalam Expo Router menangani keduanya, dengan 2 pengaturan yang berguna:
<Stack.Screen name="kamera" options={{ gestureEnabled: false, headerBackVisible: true }} />
gestureEnabled: false mematikan gestur geser untuk layar yang punya perubahan belum tersimpan, misalnya formulir panjang. Pengguna tetap bisa keluar, tapi lewat tombol yang bisa kamu beri konfirmasi.
Untuk menangani tombol kembali fisik secara khusus, gunakan hook dari React Navigation:
import { useFocusEffect } from "expo-router";
import { BackHandler } from "react-native";
useFocusEffect(() => {
const langganan = BackHandler.addEventListener("hardwareBackPress", () => {
// kembalikan true untuk menahan aksi bawaan
return true;
});
return () => langganan.remove();
});
Kesalahan yang sering terjadi
| Gejala | Penyebab | Perbaikan |
|---|---|---|
| layar kembali ke beranda setelah modal ditutup | modal dibuka dari tautan tanpa anchor | tambahkan unstable_settings.anchor |
| data tidak diperbarui setelah menambah | efek hanya berjalan saat mount | pakai useFocusEffect dengan useCallback |
| pengguna bisa kembali ke layar login | memakai push setelah login | pakai replace |
| rute terlindungi tetap terbuka lewat tautan | penjagaan hanya di tombol | jaga di layout atau Stack.Protected |
| parameter hilang setelah navigasi | memakai state lokal, bukan parameter | kirim lewat rute atau router.setParams |
| layar berkedip saat pindah tab | komponen di-mount ulang | pindahkan state ke luar komponen layar |
Latihan singkat
- Tambahkan grup
(tabs)dengan 3 tab: beranda, catatan, pengaturan. Pastikan halaman detail membuka di atas tab. - Buat rute
/catatan/[id]yang menampilkan isi catatan berdasarkan id, dan tangani id yang tidak ditemukan. - Lindungi grup pengaturan dengan sesi, lalu buka
/pengaturanlewat deep link saat belum masuk. Pastikan pengguna diarahkan ke layar masuk.
Ringkasan
Expo Router mengubah struktur folder menjadi struktur navigasi. Stack menyusun tumpukan layar, tab menyusun kelompok yang selalu terlihat, dan grup dalam tanda kurung mengelompokkan tanpa mengubah alamat. Rute dinamis membaca parameter dari URL, modal dipakai untuk formulir singkat, dan rute yang membutuhkan sesi dijaga di layout.
Bab 8 membahas data dari server: mengambil, menampilkan keadaan memuat dan gagal, serta menyimpan hasilnya supaya tidak diminta ulang setiap kali layar dibuka.