Lua Academy · leksjon

Memoisering med closures

Bufre kostbare funksjonsresultater i en tabell som holdes av en closure.

Leksjon 4 av 413 trinn

Memoisering med closures er en gratis leksjon i Lua Academy på CoddyKit. Dette er leksjon 4 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lua Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lua Academy inneholder totalt 4 leksjoner.

Hva er memoisering

Memoisering mellomlagrer resultatene fra kostbare funksjonskall, slik at gjentatte kall med de samme argumentene returnerer det mellomlagrede resultatet umiddelbart.

Enkel memoiseringswrapper

En lukking inneholder en cache-tabell. Ved første kall beregnes og lagres resultatet. Ved gjentatte kall returneres den lagrede verdien.

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

Memoisert Fibonacci

Memoisering av den rekursive Fibonacci-funksjonen reduserer tidskompleksiteten fra eksponentiell til lineær.

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

Memoisering med flere argumenter

For funksjoner med flere argumenter kan De sette sammen en streng for cache-nøkkelen basert på alle argumentene.

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

Nestede cache-tabeller

For blandede argumenttyper kan De bruke nestede tabeller med én nøkkel per argument for oppslag i O(1), uten serialisering til streng.

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

Ugyldiggjøring av cache

Memoisering forutsetter rene funksjoner (ingen bivirkninger og samme resultat for samme inndata). Funksjoner med bivirkninger bør ikke memoiseres uten nøye håndtering av cache-ugyldiggjøring.

Memoisering basert på TTL

Legg til logikk for levetid ved hjelp av os.time(), slik at mellomlagrede oppføringer utløper.

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 med svake verdier

Bruk svake verdier slik at mellomlagrede resultater kan samles av søppeloppsamleren når minnet er knapt.

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

Mønster for rekursiv memoisering

For gjensidig rekursive funksjoner må De tilordne den memoiserte wrapperen før den rekursive kroppen bruker den, slik at rekursjonen treffer cachen.

Avgrenset cache (LRU-skisse)

For å kontrollere minnebruken kan De implementere en LRU-cache som fjerner den minst nylig brukte oppføringen når cachen overskrider maksimal størrelse.

Memoisering i praksis

Vanlige bruksområder er kostbare matematiske beregninger, mellomlagring av resultater fra databasespørringer, kompilering av Lua-mønstre og tolking av konfigurasjonsfiler.

Spørsmål om memoisering

Hvorfor bør memoisering bare brukes på rene funksjoner?

Besvar den i den interaktive leksjonen

Oppsummering: Memoisering

Memoisering bruker en cache som holdes av en lukking, til å lagre resultater etter argumentnøkkel og eliminere overflødige beregninger. Bruk svake tabeller for trygg minnehåndtering, og legg til TTL for tidsfølsomme cacher.

Gratis å komme i gang

Lær deg Lua med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 40
Leksjoner: 159

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Memoisering med closures» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lua Academy, inkludert «Memoisering med closures», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lua Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «Memoisering med closures»?

Bufre kostbare funksjonsresultater i en tabell som holdes av en closure. Du øver på Lua Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Lua Academy?

Ingen tidligere erfaring er nødvendig. Lua Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 4 av 4.

Hvor lang tid tar leksjonen «Memoisering med closures»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Lua Academy-leksjonen?

Ja. Alle Lua Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Lua Academy