Lua Academy · Lección

Memoización con closures

Almacene en una tabla de una closure los resultados de funciones costosas.

Memoización con closures es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué es la memoización?

La memoización almacena en caché los resultados de llamadas costosas a funciones, de modo que las llamadas repetidas con los mismos argumentos devuelven inmediatamente el resultado almacenado.

Wrapper básico de memoización

Un closure contiene una tabla cache. En la primera llamada, calcula y almacena el resultado. En las llamadas posteriores, devuelve el valor almacenado.

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 memoizado

Memoizar la función recursiva de Fibonacci reduce su complejidad temporal de exponencial a lineal.

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

Memoización con varios argumentos

Para funciones con varios argumentos, componga una cadena de clave de caché a partir de todos los argumentos.

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

Tablas de caché anidadas

Para tipos de argumentos mixtos, use tablas anidadas con una clave por argumento para obtener búsquedas O(1) sin serializar cadenas.

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

Invalidación de caché

La memoización supone que las funciones son puras (sin efectos secundarios y con la misma salida para la misma entrada). Las funciones con efectos secundarios no deben memoizarse sin una invalidación de caché cuidadosamente diseñada.

Memoización basada en TTL

Añada una lógica de tiempo de vida mediante os.time() para que las entradas almacenadas en caché caduquen.

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

Caché de valores débiles

Use valores débiles para que los resultados almacenados en caché puedan ser recolectados por el garbage collector cuando la memoria sea escasa.

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

Patrón de memoización recursiva

Para funciones mutuamente recursivas, asigne el wrapper memoizado antes de que el cuerpo recursivo lo utilice, de modo que la recursión aproveche la caché.

Caché acotada (esquema LRU)

Para controlar la memoria, implemente una caché LRU que expulse la entrada menos utilizada recientemente cuando la caché supere un tamaño máximo.

Memoización en la práctica

Usos habituales: cálculos matemáticos costosos, almacenamiento en caché de resultados de consultas a bases de datos, compilación de patrones de Lua y análisis de archivos de configuración.

Pregunta sobre memoización

¿Por qué la memoización solo debe aplicarse a funciones puras?

Resumen: memoización

La memoización utiliza una caché contenida en un closure para almacenar resultados según la clave de los argumentos, eliminando cálculos redundantes. Use tablas débiles para gestionar la memoria de forma segura y añada un TTL a las cachés sensibles al tiempo.

Preguntas frecuentes

¿La lección «Memoización con closures» es gratis?

Sí — el texto completo de «Memoización con closures» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Memoización con closures»?

Almacene en una tabla de una closure los resultados de funciones costosas. Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Memoización con closures»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Lua Academy