Data dan State

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.

JenisContohTempat yang tepat
State lokal UIapakah modal terbuka, teks di kolom inputuseState di komponen
State milik serverdaftar catatan, profil pengguna, saldocache data fetching, atau slice khusus
State aplikasi globalsesi login, tema, keranjang belanjaContext, 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.

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

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

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

TypeScriptTS
// 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:

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

BashBASH
npm install @reduxjs/toolkit react-redux

Slice

TypeScriptTS
// 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

TypeScriptTS
// 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;
TypeScriptTS
// 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

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

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

KebutuhanAlat yang memadai
satu layar, data sementarauseState
2 atau 3 komponen bersaudaranaikkan state ke induk
tema, sesi, bahasaContext dengan useMemo
keranjang, filter, preferensi yang sering berubahZustand
alur data kompleks, banyak tim, butuh riwayat aksiRedux Toolkit
data dari servercache 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.

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

PendekatanKelebihanKekurangan
redux-persistotomatis untuk seluruh slicekonfigurasi tambahan, perlu whitelist
simpan manual di thunkeksplisit, mudah ditelusuriharus 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

GejalaPenyebabPerbaikan
layar render ulang terus-menerusselector mengembalikan objek baruuseShallow atau ambil satu bidang
data ganda saat dimuat ulangefek berjalan setiap renderperiksa status sebelum memuat
state berubah tapi tampilan tidakobjek dimutasi langsung di luar sliceubah lewat action
aplikasi lambat saat mengetikseluruh daftar disimpan di satu state globalpisahkan state input lokal
data hilang setelah aplikasi ditutuptidak ada persistensisimpan ke penyimpanan, atau pakai redux-persist

Latihan singkat

  1. Pindahkan state keranjang dari useState ke Zustand, lalu pastikan komponen lencana hanya render ulang ketika jumlah item berubah.
  2. Tambahkan slice pengaturan berisi tema terang atau gelap, dan hubungkan ke useColorScheme.
  3. 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.