Closure: Fungsi yang Mengingat

Fungsi punya ingatan

Closure terjadi ketika sebuah fungsi "mengingat" variabel dari scope tempat ia dibuat, bahkan setelah scope itu selesai dijalankan. Ini salah satu konsep paling kuat di JavaScript.

function buatCounter() {
  let hitung = 0; // variabel lokal
  return function() {
    hitung++;
    return hitung;
  };
}

const counter = buatCounter();
console.log(counter()); // 1
console.log(counter()); // 2
console.log(counter()); // 3

Fungsi buatCounter sudah selesai dijalankan, tapi fungsi yang dikembalikannya masih ingat variabel hitung. Setiap pemanggilan counter() menambah nilai yang sama.

Analoginya

Bayangkan fungsi dalam seperti anak yang dibesarkan di sebuah rumah (scope luar). Saat anak itu pergi merantau (dikembalikan keluar), ia tetap ingat isi rumahnya. Rumahnya mungkin sudah "tutup", tapi ingatannya tetap ada.

Kegunaan praktis: data privat

Closure memungkinkan membuat variabel yang tidak bisa diakses langsung dari luar, hanya lewat fungsi tertentu:

function buatTabungan() {
  let saldo = 0;
  return {
    setor: (n) => { saldo += n; },
    cek: () => saldo
  };
}
const tab = buatTabungan();
tab.setor(100);
console.log(tab.cek()); // 100
console.log(tab.saldo); // undefined, tidak bisa diakses langsung!

Ini dasar dari enkapsulasi: data privat yang hanya bisa diubah lewat jalur resmi.

Catatan teknis: Jebakan klasik closure adalah loop dengan var. Karena var tidak punya block scope, semua iterasi berbagi satu variabel yang sama sehingga hasilnya tidak sesuai harapan. Solusinya: pakai let yang membuat salinan baru tiap iterasi.

Contoh nyata: tombol like privat

Closure sering dipakai untuk state yang tidak boleh diubah sembarangan dari luar:

function buatLike() {
  let jumlah = 0; // privat, tidak bisa diakses langsung
  return {
    klik: function() {
      jumlah++;
      return jumlah;
    },
    reset: function() {
      jumlah = 0;
    }
  };
}

let likeFoto1 = buatLike();
let likeFoto2 = buatLike();

console.log(likeFoto1.klik()); // 1
console.log(likeFoto1.klik()); // 2
console.log(likeFoto2.klik()); // 1, independen!

Tiap pemanggilan buatLike() menciptakan closure baru dengan variabel jumlah sendiri. likeFoto1 dan likeFoto2 tidak saling mengganggu. Inilah dasar pola module dan state management sederhana sebelum ada framework.

Kesimpulan

Closure = fungsi + ingatan akan scopenya. Konsep ini dipakai di mana-mana: event handler, callback async, sampai module pattern. Pahami contoh counter di atas sampai benar-benar jelas, karena ia fondasi banyak pola lanjutan.