BAB 6: State Management
Dari useState ke Context, lalu Redux Toolkit: kapan state lokal tidak lagi cukup, cara memilih alat, dan cara menghindari re-render yang tidak perlu.
Bab 5 berhenti pada komponen yang tampil rapi. Begitu data harus dipakai di beberapa layar sekaligus, muncul pertanyaan yang lebih sulit: di mana data itu sebaiknya disimpan.
Bab ini bergerak bertahap. Dimulai dari state lokal yang paling sederhana, lalu naik hanya ketika ada alasan yang jelas. Sebagian besar aplikasi tidak membutuhkan Redux, dan memaksakannya sejak awal menghasilkan kode yang lebih rumit tanpa manfaat.
3 jenis state
Membedakan jenis state mencegah kesalahan menempatkan data di tempat yang salah.
| Jenis | Contoh | Tempat yang tepat |
|---|---|---|
| State lokal UI | apakah modal terbuka, teks di kolom input | useState di komponen |
| State milik server | daftar catatan, profil pengguna, saldo | cache data fetching, atau slice khusus |
| State aplikasi global | sesi login, tema, keranjang belanja | Context, Zustand, atau Redux |
Kesalahan yang paling sering: menaruh state server ke dalam store global, padahal data itu dimiliki server dan bisa berubah kapan saja tanpa aplikasi tahu.
Mulai dari useState
Untuk satu layar, useState sudah cukup. Jangan menambah alat sebelum ada gejala yang menuntut.
const [judul, setJudul] = useState("");
const [menyimpan, setMenyimpan] = useState(false);
Ketika 2 komponen bersaudara butuh data yang sama, naikkan state ke induknya. Pola ini disebut lifting state up, dan biasanya menyelesaikan masalah tanpa library tambahan.
function IndukLayar() {
const [kataKunci, setKataKunci] = useState("");
return (
<>
<KolomCari nilai={kataKunci} onUbah={setKataKunci} />
<DaftarHasil kataKunci={kataKunci} />
</>
);
}
Gejala yang menandakan state perlu naik tingkat:
- data yang sama diambil ulang di beberapa layar
- prop diteruskan melewati 4 lapis komponen hanya untuk sampai ke tujuan
- 2 layar harus menampilkan data yang selalu identik
Context: untuk data yang jarang berubah
Context menyediakan nilai ke seluruh pohon komponen tanpa meneruskan prop. Cocok untuk data yang stabil, seperti tema atau sesi pengguna.
// context/SesiContext.tsx
import { createContext, useContext, useMemo, useState, type ReactNode } from "react";
type Sesi = { nama: string; keluar: () => void };
const Konteks = createContext<Sesi | null>(null);
export function PenyediaSesi({ children }: { children: ReactNode }) {
const [nama, setNama] = useState("Budi");
const nilai = useMemo(() => ({ nama, keluar: () => setNama("") }), [nama]);
return <Konteks.Provider value={nilai}>{children}</Konteks.Provider>;
}
export function useSesi() {
const nilai = useContext(Konteks);
if (!nilai) throw new Error("useSesi harus dipakai di dalam PenyediaSesi");
return nilai;
}
2 hal yang menentukan apakah Context akan menjadi masalah:
Pertama, value harus dibungkus useMemo. Tanpa itu, setiap render penyedia membuat objek baru, dan semua konsumen ikut render ulang.
Kedua, Context tidak bisa memilih sebagian nilai. Setiap konsumen akan render ulang ketika nilai berubah, bahkan jika hanya memakai satu bidang. Untuk data yang sering berubah, ini menjadi mahal.
Zustand: ringan dan tanpa boilerplate
Zustand menyimpan state di luar pohon React, dan komponen hanya berlangganan bagian yang dipakai.
// store/keranjang.ts
import { create } from "zustand";
type Item = { id: string; nama: string; harga: number; jumlah: number };
type Keranjang = {
item: Item[];
tambah: (item: Item) => void;
hapus: (id: string) => void;
total: () => number;
};
export const useKeranjang = create<Keranjang>((set, get) => ({
item: [],
tambah: (baru) =>
set((s) => ({
item: s.item.some((i) => i.id === baru.id)
? s.item.map((i) => (i.id === baru.id ? { ...i, jumlah: i.jumlah + 1 } : i))
: [...s.item, { ...baru, jumlah: 1 }],
})),
hapus: (id) => set((s) => ({ item: s.item.filter((i) => i.id !== id) })),
total: () => get().item.reduce((n, i) => n + i.harga * i.jumlah, 0),
}));
Pemakaian di komponen, dengan pemilihan sebagian state:
function LencanaKeranjang() {
const jumlah = useKeranjang((s) => s.item.length);
return <Text>{jumlah} item</Text>;
}
Komponen itu hanya render ulang ketika jumlah item berubah, bukan ketika harga salah satu item berubah.
Redux Toolkit: ketika aplikasi tumbuh
Redux Toolkit adalah cara resmi memakai Redux hari ini. Boilerplate yang dulu menjadi keluhan sudah dihapus: satu berkas slice memuat state, action, dan reducer sekaligus.
npm install @reduxjs/toolkit react-redux
Slice
// store/catatanSlice.ts
import { createAsyncThunk, createSlice, type PayloadAction } from "@reduxjs/toolkit";
import { bacaSemua, tulisSemua } from "../lib/penyimpanan";
import type { Catatan } from "../types";
type Status = "idle" | "memuat" | "siap" | "gagal";
type State = { daftar: Catatan[]; status: Status; galat: string | null };
const awal: State = { daftar: [], status: "idle", galat: null };
export const muatCatatan = createAsyncThunk("catatan/muat", async () => bacaSemua());
export const simpanCatatan = createAsyncThunk("catatan/simpan", async (baru: Catatan, { getState }) => {
const state = getState() as { catatan: State };
const berikutnya = [baru, ...state.catatan.daftar];
await tulisSemua(berikutnya);
return berikutnya;
});
const slice = createSlice({
name: "catatan",
initialState: awal,
reducers: {
hapus(state, action: PayloadAction<string>) {
state.daftar = state.daftar.filter((c) => c.id !== action.payload);
},
},
extraReducers: (builder) => {
builder
.addCase(muatCatatan.pending, (state) => {
state.status = "memuat";
state.galat = null;
})
.addCase(muatCatatan.fulfilled, (state, action) => {
state.status = "siap";
state.daftar = action.payload;
})
.addCase(muatCatatan.rejected, (state, action) => {
state.status = "gagal";
state.galat = action.error.message ?? "Gagal memuat";
})
.addCase(simpanCatatan.fulfilled, (state, action) => {
state.daftar = action.payload;
});
},
});
export const { hapus } = slice.actions;
export default slice.reducer;
Perhatikan bahwa reducers menulis state seolah-olah memutasi objek langsung. Redux Toolkit memakai Immer di baliknya, sehingga perubahan itu tetap menghasilkan state baru tanpa kamu menulis spread berlapis.
Store dan hook bertipe
// store/index.ts
import { configureStore } from "@reduxjs/toolkit";
import catatanReducer from "./catatanSlice";
export const store = configureStore({
reducer: { catatan: catatanReducer },
});
export type RootState = ReturnType<typeof store.getState>;
export type AppDispatch = typeof store.dispatch;
// store/hooks.ts
import { useDispatch, useSelector } from "react-redux";
import type { AppDispatch, RootState } from "./index";
export const useAppDispatch = useDispatch.withTypes<AppDispatch>();
export const useAppSelector = useSelector.withTypes<RootState>();
Memasang penyedia
// app/_layout.tsx
import { Provider } from "react-redux";
import { store } from "../store";
export default function Kerangka({ children }: { children: React.ReactNode }) {
return <Provider store={store}>{children}</Provider>;
}
Memakai di layar
function DaftarCatatan() {
const dispatch = useAppDispatch();
const { daftar, status, galat } = useAppSelector((s) => s.catatan);
useEffect(() => {
if (status === "idle") dispatch(muatCatatan());
}, [status, dispatch]);
if (status === "memuat") return <ActivityIndicator />;
if (status === "gagal") return <Text>{galat}</Text>;
return (
<FlatList
data={daftar}
keyExtractor={(item) => item.id}
renderItem={({ item }) => (
<ItemCatatan catatan={item} onHapus={() => dispatch(hapus(item.id))} />
)}
/>
);
}
Pemeriksaan status === "idle" mencegah pemuatan berulang setiap layar dibuka kembali.
Memilih alat tanpa perdebatan
| Kebutuhan | Alat yang memadai |
|---|---|
| satu layar, data sementara | useState |
| 2 atau 3 komponen bersaudara | naikkan state ke induk |
| tema, sesi, bahasa | Context dengan useMemo |
| keranjang, filter, preferensi yang sering berubah | Zustand |
| alur data kompleks, banyak tim, butuh riwayat aksi | Redux Toolkit |
| data dari server | cache data fetching seperti TanStack Query |
Baris terakhir layak ditekankan. Untuk data server, Redux sering bukan pilihan terbaik, karena kamu harus menulis sendiri logika cache, kedaluwarsa, dan pemuatan ulang. Bab 8 membahas alat yang memang dibuat untuk itu.
Menghindari re-render yang tidak perlu
3 kebiasaan berikut menyelesaikan sebagian besar masalah performa pada state global.
Pilih sebagian state, bukan seluruhnya. useAppSelector((s) => s.catatan.daftar) lebih baik daripada mengambil objek catatan utuh, karena perubahan status tidak memicu render ulang layar yang hanya butuh daftar.
Simpan data dalam bentuk yang datar. Menyimpan array bersarang memaksa pembaruan menyalin banyak lapis. Untuk relasi, simpan Record<string, Item> ditambah array id.
Hati-hati dengan objek baru di selector. Selector yang mengembalikan objek baru setiap panggilan, misalnya s => ({ a: s.a, b: s.b }), membuat perbandingan selalu menganggap nilai berubah. Pakai useShallow dari react-redux, atau ambil satu per satu.
import { useShallow } from "react-redux";
const { daftar, status } = useAppSelector(useShallow((s) => ({ daftar: s.catatan.daftar, status: s.catatan.status })));
Menyimpan state ke disk
Untuk data yang harus bertahan setelah aplikasi ditutup, 2 pilihan umum:
| Pendekatan | Kelebihan | Kekurangan |
|---|---|---|
redux-persist | otomatis untuk seluruh slice | konfigurasi tambahan, perlu whitelist |
| simpan manual di thunk | eksplisit, mudah ditelusuri | harus diingat di setiap aksi |
Untuk aplikasi kecil, simpan manual di thunk lebih mudah dipahami. Untuk aplikasi dengan banyak slice, redux-persist menghemat waktu.
Satu hal yang jangan disimpan: token sesi di penyimpanan biasa. Gunakan penyimpanan terenkripsi yang disediakan sistem, seperti SecureStore di Expo.
Kesalahan yang sering terjadi
| Gejala | Penyebab | Perbaikan |
|---|---|---|
| layar render ulang terus-menerus | selector mengembalikan objek baru | useShallow atau ambil satu bidang |
| data ganda saat dimuat ulang | efek berjalan setiap render | periksa status sebelum memuat |
| state berubah tapi tampilan tidak | objek dimutasi langsung di luar slice | ubah lewat action |
| aplikasi lambat saat mengetik | seluruh daftar disimpan di satu state global | pisahkan state input lokal |
| data hilang setelah aplikasi ditutup | tidak ada persistensi | simpan ke penyimpanan, atau pakai redux-persist |
Latihan singkat
- Pindahkan state keranjang dari
useStateke Zustand, lalu pastikan komponen lencana hanya render ulang ketika jumlah item berubah. - Tambahkan slice
pengaturanberisi tema terang atau gelap, dan hubungkan keuseColorScheme. - Tulis selector yang mengembalikan total harga, dan pastikan nilainya tidak dihitung ulang saat state lain berubah.
Ringkasan
Sebagian besar state cukup ditangani useState dan menaikkan state ke induk. Context berguna untuk data yang jarang berubah, Zustand untuk state global yang ringan, dan Redux Toolkit ketika alur data melibatkan banyak pihak dan perlu ketertelusuran. Untuk data dari server, alat khusus data fetching lebih tepat daripada store global.
Bab 7 membahas perpindahan antar layar: rute bersarang, parameter, dan menjaga state saat pengguna menekan tombol kembali.