Module Pattern adalah cara mengorganisasi kode menjadi unit-unit mandiri dengan public dan private interface. Di JavaScript modern, ini sudah built-in lewat ES Modules (import/export), tapi memahami polanya tetap penting.

Masalah yang diselesaikan:

• Mencegah polusi global namespace
• Menyembunyikan implementasi internal (encapsulation)
• Mengorganisasi kode jadi modular dan reusable

Versi klasik — IIFE (Immediately Invoked Function Expression):

const Counter = (function() {
  // Private — tidak bisa diakses dari luar
  let count = 0;

  // Public — interface yang di-expose
  return {
    increment() { count++; },
    decrement() { count--; },
    getCount() { return count; }
  };
})();

Counter.increment();
Counter.increment();
console.log(Counter.getCount()); // 2
console.log(Counter.count);      // undefined — private!

Versi modern — ES Modules:

// counter.js
let count = 0; // Private ke module ini

export function increment() { count++; }
export function decrement() { count--; }
export function getCount() { return count; }
// Variable `count` tidak di-export, jadi private

// app.js
import { increment, getCount } from "./counter.js";
increment();
console.log(getCount()); // 1

Revealing Module Pattern:

const Calculator = (function() {
  let result = 0;

  function add(x) { result += x; }
  function subtract(x) { result -= x; }
  function getResult() { return result; }
  function reset() { result = 0; }

  // "Reveal" hanya yang perlu diakses publik
  return { add, subtract, getResult, reset };
})();

Penggunaan di dunia nyata:

• Node.js modules — setiap file adalah module (module.exports)
• React custom hooks — expose state & actions, sembunyikan logic
• Utility libraries — export fungsi yang diperlukan, sembunyikan helper internal

// React custom hook = Module Pattern!
function useAuth() {
  // Private state & logic
  const [user, setUser] = useState(null);
  const [loading, setLoading] = useState(true);

  useEffect(() => { /* fetch user */ }, []);

  // Public interface
  return { user, loading, login, logout };
}

Kapan pakai Module Pattern:

• Saat kamu perlu encapsulation — pisahkan public dari private
• Saat ingin menghindari nama variable yang bentrok
• Saat membuat utility/helper yang self-contained