Lua Academy · Pelajaran

Memoisasi dengan Closure

Simpan hasil fungsi yang mahal di dalam tabel yang dikelola closure.

Memoisasi dengan Closure adalah pelajaran Lua Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Lua Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Lua Academy mencakup 4 pelajaran total.

Apa Itu Memo?

Memo menyimpan hasil pemanggilan fungsi yang mahal dijalankan, sehingga pemanggilan berulang dengan argumen yang sama dapat langsung mengembalikan hasil yang tersimpan.

Pembungkus Memo Dasar

Sebuah fungsi penutup menyimpan tabel cache. Pada pemanggilan pertama, lakukan perhitungan dan simpan hasilnya. Pada pemanggilan berikutnya, kembalikan nilai yang tersimpan.

local function memoize(fn)
  local cache = {}
  return function(x)
    if cache[x] == nil then
      cache[x] = fn(x)
    end
    return cache[x]
  end
end

Fibonacci dengan Memo

Pemberian memo pada fungsi Fibonacci rekursif mengurangi kompleksitas waktunya dari eksponensial menjadi linear.

local fib
fib = memoize(function(n)
  if n <= 1 then return n end
  return fib(n-1) + fib(n-2)
end)
print(fib(30))  -- 832040 (fast!)

Memo dengan Banyak Argumen

Untuk fungsi dengan beberapa argumen, susun string kunci tembolok dari semua argumen.

local function memoize2(fn)
  local cache = {}
  return function(a, b)
    local key = a .. "," .. b
    if cache[key] == nil then cache[key] = fn(a, b) end
    return cache[key]
  end
end

Tabel Tembolok Bersarang

Untuk jenis argumen yang beragam, gunakan tabel bersarang yang dikunci oleh setiap argumen agar pencarian O(1) dapat dilakukan tanpa serialisasi string.

local function nestedMemo(fn)
  local cache = {}
  return function(a, b)
    cache[a] = cache[a] or {}
    if cache[a][b] == nil then cache[a][b] = fn(a, b) end
    return cache[a][b]
  end
end

Invalidasi Tembolok

Memo mengasumsikan fungsi murni (tanpa efek samping, keluaran yang sama untuk masukan yang sama). Fungsi dengan efek samping tidak boleh diberi memo tanpa invalidasi tembolok yang cermat.

Memo Berbasis TTL

Tambahkan logika masa berlaku menggunakan os.time() untuk membuat entri tembolok kedaluwarsa.

local function memoizeTTL(fn, ttl)
  local cache = {}
  return function(x)
    local entry = cache[x]
    if entry and os.time() - entry.time < ttl then
      return entry.value
    end
    cache[x] = {value = fn(x), time = os.time()}
    return cache[x].value
  end
end

Tembolok Nilai Lemah

Gunakan nilai lemah agar hasil yang disimpan dapat dikumpulkan oleh pengumpul sampah ketika memori terbatas.

local function memoizeWeak(fn)
  local cache = setmetatable({}, {__mode = "v"})
  return function(x)
    if cache[x] == nil then cache[x] = fn(x) end
    return cache[x]
  end
end

Pola Memo Rekursif

Untuk fungsi yang saling rekursif, tetapkan pembungkus memo sebelum badan rekursif menggunakannya, sehingga rekursi dapat memanfaatkan tembolok.

Tembolok Terbatas (Sketsa LRU)

Untuk mengendalikan memori, terapkan tembolok LRU yang mengeluarkan entri yang paling lama tidak digunakan saat ukuran tembolok melebihi batas maksimum.

Memo dalam Praktik

Penggunaan umum: perhitungan matematika yang mahal, penyimpanan hasil kueri basis data, kompilasi pola Lua, dan penguraian berkas konfigurasi.

Pertanyaan tentang Memo

Mengapa memo hanya boleh diterapkan pada fungsi murni?

Ringkasan: Memo

Memo menggunakan tembolok yang disimpan oleh fungsi penutup untuk menyimpan hasil berdasarkan kunci argumen, sehingga menghilangkan perhitungan yang berulang. Gunakan tabel lemah untuk keamanan memori dan tambahkan TTL untuk tembolok yang sensitif terhadap waktu.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Memoisasi dengan Closure” gratis?

Ya — teks lengkap “Memoisasi dengan Closure” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Lua Academy, upgrade ke CoddyKit PRO. Kursus Lua Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Memoisasi dengan Closure”?

Simpan hasil fungsi yang mahal di dalam tabel yang dikelola closure. Kamu berlatih Lua Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Lua Academy?

Tidak diperlukan pengalaman sebelumnya. Lua Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Memoisasi dengan Closure” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Lua Academy ini?

Ya. Setiap pelajaran Lua Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke Lua Academy