Lua Academy · Lezione

Memoization con le closure

Memorizzi nella cache i risultati costosi delle funzioni in una tabella contenuta in una closure.

Memoization con le closure è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Che cos’è la memoizzazione?

La memoizzazione memorizza nella cache i risultati delle chiamate a funzioni costose, così le chiamate successive con gli stessi argomenti restituiscono immediatamente il risultato memorizzato.

Wrapper di memoizzazione di base

Una closure contiene una tabella cache. Alla prima chiamata, calcola e memorizza il risultato. Nelle chiamate successive, restituisce il valore memorizzato.

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

Memoizzazione di Fibonacci

La memoizzazione della funzione ricorsiva di Fibonacci riduce la complessità temporale da esponenziale a lineare.

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!)

Memoizzazione con più argomenti

Per le funzioni con più argomenti, componga una stringa chiave per la cache a partire da tutti gli argomenti.

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

Tabelle di cache annidate

Per tipi di argomento eterogenei, utilizzi tabelle annidate indicizzate da ciascun argomento, così da ottenere una ricerca O(1) senza serializzazione in stringa.

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

Invalidazione della cache

La memoizzazione presuppone funzioni pure (senza effetti collaterali e con lo stesso risultato per lo stesso input). Le funzioni con effetti collaterali non devono essere memoizzate senza un’attenta invalidazione della cache.

Memoizzazione basata sul TTL

Aggiunga una logica time-to-live utilizzando os.time() per far scadere le voci memorizzate nella cache.

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

Cache con valori deboli

Utilizzi valori deboli, in modo che i risultati memorizzati nella cache possano essere raccolti dal garbage collector quando la memoria scarseggia.

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

Pattern di memoizzazione ricorsiva

Per funzioni mutuamente ricorsive, assegni il wrapper memoizzato prima che il corpo ricorsivo lo utilizzi, così la ricorsione passa dalla cache.

Cache limitata (schema LRU)

Per controllare l’uso della memoria, implementi una cache LRU che espella la voce usata meno di recente quando la cache supera una dimensione massima.

Memoizzazione nella pratica

Usi comuni: calcoli matematici costosi, memorizzazione nella cache dei risultati delle query al database, compilazione di pattern Lua e analisi dei file di configurazione.

Domanda sulla memoizzazione

Perché la memoizzazione dovrebbe essere applicata solo alle funzioni pure?

Riepilogo: memoizzazione

La memoizzazione utilizza una cache mantenuta da una closure per memorizzare i risultati in base alla chiave degli argomenti, eliminando i calcoli ridondanti. Utilizzi tabelle deboli per gestire la memoria e aggiunga un TTL alle cache sensibili al tempo.

Domande Frequenti

La lezione «Memoization con le closure» è gratuita?

Sì — il testo completo di «Memoization con le closure» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Memoization con le closure»?

Memorizzi nella cache i risultati costosi delle funzioni in una tabella contenuta in una closure. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Memoization con le closure»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Lua Academy