Lua Academy · Aula

Memoização com fechamentos

Armazene em cache resultados dispendiosos de funções dentro de uma tabela mantida por um fechamento.

Memoização com fechamentos é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

O que é memorização?

Memorização armazena em cache os resultados de chamadas de funções dispendiosas, para que chamadas repetidas com os mesmos argumentos retornem instantaneamente o resultado armazenado.

Invólucro básico de memorização

Um fechamento mantém uma tabela de cache. Na primeira chamada, calcula e armazena. Nas chamadas seguintes, retorna o valor armazenado.

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 com memorização

Aplicar memorização à função recursiva de Fibonacci reduz sua complexidade de tempo de exponencial para 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!)

Memorização com vários argumentos

Para funções com vários argumentos, componha uma cadeia de chave de cache com todos os 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

Tabelas de cache aninhadas

Para tipos de argumentos mistos, use tabelas aninhadas indexadas por cada argumento, obtendo consulta O(1) sem serialização em cadeia.

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

Invalidação de cache

A memorização pressupõe funções puras (sem efeitos colaterais e com a mesma saída para a mesma entrada). Funções com efeitos colaterais não devem ser memorizadas sem uma invalidação cuidadosa do cache.

Memorização baseada em TTL

Adicione uma lógica de tempo de vida usando os.time() para expirar as entradas armazenadas em 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 de valores fracos

Use valores fracos para que os resultados armazenados em cache possam ser coletados pelo coletor de lixo quando houver pouca memória.

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

Padrão de memorização recursiva

Para funções mutuamente recursivas, atribua o invólucro memorizado antes que o corpo recursivo o utilize, para que a recursão aproveite o cache.

Cache limitado (esboço de LRU)

Para controlar a memória, implemente um cache LRU que remova a entrada usada há mais tempo quando o cache exceder um tamanho máximo.

Memorização na prática

Usos comuns: cálculos matemáticos dispendiosos, armazenamento em cache de resultados de consultas ao banco de dados, compilação de padrões Lua e análise de arquivos de configuração.

Pergunta sobre memorização

Por que a memorização deve ser aplicada somente a funções puras?

Recapitulação: memorização

Memorização usa um cache mantido por um fechamento para armazenar resultados por chave de argumento, eliminando cálculos redundantes. Use tabelas fracas para garantir a segurança da memória e adicione TTL para caches sensíveis ao tempo.

Perguntas Frequentes

A aula “Memoização com fechamentos” é grátis?

Sim — o texto completo de “Memoização com fechamentos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Memoização com fechamentos”?

Armazene em cache resultados dispendiosos de funções dentro de uma tabela mantida por um fechamento. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Memoização com fechamentos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

O que são upvalues?
Upvalues compartilhados entre fechamentos
Funções fábrica e geradores
Memoização com fechamentos

← Voltar para Lua Academy