Ilustrasi flat vector kotak perkakas berisi modul-modul kecil siap pakai sebagai simbol custom hooks

Di episode #115 kamu mengatur navigasi, di #116 kamu mendistribusikan data global. Sekarang kita menyelesaikan segitiga arsitektur React: mendistribusikan LOGIKA. Masalahnya familiar: tiga component berbeda semuanya butuh fetch data dari API, dan ketiganya menulis useState + useEffect + fetch yang hampir identik. Copy-paste tiga kali, bug diperbaiki tiga kali.

Solusinya adalah custom hooks: function biasa yang namanya diawali use dan boleh memanggil hooks lain di dalamnya. Ia membungkus logika stateful menjadi satu unit reusable. Posisinya di perjalanan belajarmu: ini adalah skill arsitektur, bukan sekadar syntax. Programmer React yang baik dikenali dari kemampuannya mengekstrak logika, bukan dari hafalan API. Series React Lanjutan berlanjut setelah ini, dan custom hooks akan muncul terus di episode-episode berikutnya.

Cara Berpikirnya: Resep, Bukan Masakan Jadi

Bayangkan kamu punya tiga warung. Masing-masing butuh sambal yang sama. Opsi pertama: tiap warung bikin sambal sendiri dengan resep yang dihafal tidak persis sama. Hasilnya beda-beda, dan kalau resepnya diperbaiki, harus keliling ke tiga warung. Opsi kedua: tulis resepnya sekali, tiap warung mengikuti resep yang sama. Perbaiki resepnya sekali, semua warung ikut membaik.

Custom hook adalah resep itu. Contoh paling klasik, useFetch:

import { useState, useEffect } from "react";

function useFetch(url) {
  const [data, setData] = useState(null);
  const [loading, setLoading] = useState(true);
  const [error, setError] = useState(null);

  useEffect(() => {
    let batal = false;
    setLoading(true);
    fetch(url)
      .then((res) => {
        if (!res.ok) throw new Error("Gagal mengambil data");
        return res.json();
      })
      .then((json) => { if (!batal) setData(json); })
      .catch((err) => { if (!batal) setError(err); })
      .finally(() => { if (!batal) setLoading(false); });
    return () => { batal = true; };
  }, [url]);

  return { data, loading, error };
}

// Pakainya: satu baris!
function DaftarUser() {
  const { data, loading, error } = useFetch("https://api.example.com/users");
  if (loading) return <p>Memuat...</p>;
  if (error) return <p>Terjadi kesalahan.</p>;
  return <ul>{data.map((u) => <li key={u.id}>{u.nama}</li>)}</ul>;
}

Perhatikan apa yang hilang dari DaftarUser: tidak ada useEffect, tidak ada fetch, tidak ada state loading/error. Component-nya kembali ke tugas aslinya: menampilkan UI. Seluruh kerumitan async (loading, error, race condition lewat flag batal) terkunci di dalam hook. Dan DaftarProduk cukup memanggil useFetch dengan URL berbeda untuk mendapat perilaku yang sama persis.

Berhenti dan tebak dulu! Dua component memanggil useFetch masing-masing: DaftarUser dengan URL /users dan DaftarProduk dengan URL /products. Apakah state data mereka saling berbagi (satu berubah, yang lain ikut berubah)?

Jawaban: TIDAK berbagi. Setiap pemanggilan hook punya state yang terisolasi penuh. Ini perbedaan fundamental custom hooks vs context: custom hooks me-reuse LOGIKA, bukan STATE. Resepnya sama, tapi tiap warung bikin sambalnya sendiri-sendiri. Kalau kamu butuh state yang benar-benar dibagi (satu keranjang belanja untuk semua halaman), itu tugas context (#116) atau state management library, bukan custom hooks. Salah kaprah ini adalah sumber bug yang membingungkan: "kok datanya tidak sinkron?" karena mengira hook berbagi state.

Dua Persepsi Salah yang Perlu Diluruskan

Mitos 1: "Custom hook itu fitur ajaib React yang punya cara kerja khusus." Tidak ada yang ajaib. Custom hook adalah function JavaScript biasa yang kebetulan memanggil hooks bawaan di dalamnya. Satu-satunya "keajaiban" adalah konvensi nama use... yang memberi tahu React dan linter bahwa function ini terikat Rules of Hooks (hanya dipanggil di top level component atau hook lain, tidak di dalam if/loop). Memahaminya sebagai function biasa menghilangkan separuh kebingungan.

Mitos 2: "Setiap function yang dipakai ulang harus jadi custom hook." Hanya function yang memakai hooks (useState, useEffect, dsb.) yang layak jadi custom hook. Function murni seperti formatRupiah tetap function biasa saja. Aturannya: kalau tidak ada hooks di dalamnya, jangan beri nama use..., karena nama itu adalah janji tentang cara pakai (terikat Rules of Hooks) yang tidak perlu ditepati oleh function biasa.

Contoh Kedua: useLocalStorage

Supaya terlihat bahwa pola ini umum, contoh lain yang sangat praktis: state yang tersimpan otomatis di localStorage.

import { useState, useEffect } from "react";

function useLocalStorage(kunci, nilaiAwal) {
  const [nilai, setNilai] = useState(() => {
    const tersimpan = localStorage.getItem(kunci);
    return tersimpan ? JSON.parse(tersimpan) : nilaiAwal;
  });

  useEffect(() => {
    localStorage.setItem(kunci, JSON.stringify(nilai));
  }, [kunci, nilai]);

  return [nilai, setNilai];
}

// Pakainya persis seperti useState!
function Pengaturan() {
  const [tema, setTema] = useLocalStorage("tema", "terang");
  return <button onClick={() => setTema(tema === "terang" ? "gelap" : "terang")}>
    Tema: {tema}
  </button>;
}

Alur berpikirnya: hook ini meniru API useState (mengembalikan [nilai, setNilai]) tapi diam-diam menambahkan persistensi. Component pemakainya tidak tahu-menahu soal localStorage. Inilah kekuatan abstraksi yang baik: antarmuka sederhana, perilaku kaya. Dan perhatikan inisialisasi lazy useState(() => ...): membaca localStorage hanya sekali saat pertama, bukan tiap render.

Sebelum menutup, satu peringatan tentang Rules of Hooks yang mengikat semua custom hooks: hooks hanya boleh dipanggil di top level (tidak di dalam if, loop, atau nested function), dan hanya dari component React atau custom hook lain. Kenapa aturannya kaku begitu? Karena React mengandalkan urutan pemanggilan untuk mencocokkan state dengan hook yang tepat. Kalau kamu memanggil useState di dalam if yang kadang true kadang false, urutannya berubah antar render dan React mencocokkan state ke hook yang salah: bug yang sangat membingungkan. Linter eslint-plugin-react-hooks akan menangkap pelanggaran ini otomatis, jadi pastikan ia terinstall di proyekmu. Aturan ini bukan birokrasi, ia adalah fondasi yang membuat seluruh sistem hooks bisa bekerja.

Aturan Main Membuat Custom Hooks

  • Nama selalu diawali use: useFetch, useLocalStorage, useDebounce. Ini bukan gaya, ini kontrak dengan React.
  • Ekstrak saat logika muncul 2-3 kali: sama seperti aturan component di episode #113. Jangan mengekstrak terlalu dini; duplikasi dua kali masih memberi informasi tentang pola yang tepat.
  • Kembalikan API yang nyaman: tiru pola bawaan React. [nilai, setter] untuk yang mirip state, { data, loading, error } untuk yang mirip fetch. Konsistensi API membuat hook-mu mudah ditebak cara pakainya.
  • Satu hook, satu tanggung jawab: useFetch mengurus fetch. Jangan selipkan logika form ke dalamnya. Hook yang fokus mudah ditest dan mudah dipakai ulang.
  • Ingat: logika dibagi, state tidak. Kalau butuh state bersama, gabungkan dengan context: provider memakai custom hook di dalamnya, component memakai useContext. Ini pola profesional yang akan kamu lihat di banyak codebase.

Kuis cepat: Apa perbedaan utama custom hooks dan context?

Latihan: Bukan Mengetik Ulang

  1. Salin useFetch dari artikel ini ke proyekmu. Buat dua component yang memakai API publik https://jsonplaceholder.typicode.com (endpoint /users dan /posts). Verifikasi loading dan error state bekerja.
  2. Ubah: tambahkan fitur refetch ke hook-mu: kembalikan juga function yang memicu fetch ulang saat dipanggil. Pikirkan sendiri cara memicunya (petunjuk: state counter yang masuk dependency useEffect).
  3. Tambah: buat useDebounce(nilai, jeda): hook yang mengembalikan nilai yang "terlambat" mengikuti input setelah jeda tertentu. Pakai untuk input pencarian supaya API tidak dipanggil tiap ketikan. Ini hook klasik yang sering ditanyakan di interview.
  4. Tantangan: gabungkan keduanya, buat useUser() custom hook yang di dalamnya memakai useContext(UserContext) dari episode #116. Satu baris const { user, login } = useUser() di component mana pun. Rasakan betapa rapi arsitekturmu sekarang.

Series React Lanjutan berlanjut di episode berikutnya dengan topik yang lebih dalam lagi. Tiga episode ini (#115-117) memberimu fondasi arsitektur: routing untuk navigasi, context untuk data global, custom hooks untuk logika reusable. Latihan tantangannya jangan dilewatkan, karena pola useUser() itu akan menjadi template untuk setiap fitur global yang kamu bangun ke depannya.