Data dan State

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

BerkasRute
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.

React TSXTSX
// 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.

CodeCODE
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
React TSXTSX
// 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.

React TSXTSX
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");
PerintahEfek pada riwayat
router.pushmenambah layar baru, tombol kembali tersedia
router.replacemengganti layar sekarang, riwayat layar itu hilang
router.backkembali satu layar
router.dismissmenutup 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.

React TSXTSX
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.

React TSXTSX
// 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 cocok untuk formulir singkat yang tidak perlu mengubah konteks pengguna.

React TSXTSX
<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:

React TSXTSX
// 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.

React TSXTSX
// 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.

React TSXTSX
<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.

React TSXTSX
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.

Setiap rute sudah punya alamat, dan alamat itu bisa dibuka dari luar aplikasi. Yang perlu disiapkan hanya skema di konfigurasi aplikasi:

{}JSON
{
  "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:

BashBASH
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:

React TSXTSX
<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:

React TSXTSX
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

GejalaPenyebabPerbaikan
layar kembali ke beranda setelah modal ditutupmodal dibuka dari tautan tanpa anchortambahkan unstable_settings.anchor
data tidak diperbarui setelah menambahefek hanya berjalan saat mountpakai useFocusEffect dengan useCallback
pengguna bisa kembali ke layar loginmemakai push setelah loginpakai replace
rute terlindungi tetap terbuka lewat tautanpenjagaan hanya di tomboljaga di layout atau Stack.Protected
parameter hilang setelah navigasimemakai state lokal, bukan parameterkirim lewat rute atau router.setParams
layar berkedip saat pindah tabkomponen di-mount ulangpindahkan state ke luar komponen layar

Latihan singkat

  1. Tambahkan grup (tabs) dengan 3 tab: beranda, catatan, pengaturan. Pastikan halaman detail membuka di atas tab.
  2. Buat rute /catatan/[id] yang menampilkan isi catatan berdasarkan id, dan tangani id yang tidak ditemukan.
  3. Lindungi grup pengaturan dengan sesi, lalu buka /pengaturan lewat 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.