Lua Academy · Leçon

Mémorisation avec des fermetures

Mettez en cache les résultats coûteux d’une fonction dans une table conservée par une fermeture.

Mémorisation avec des fermetures est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Qu’est-ce que la mémorisation ?

La mémorisation met en cache les résultats des appels coûteux afin que les appels répétés avec les mêmes arguments renvoient instantanément le résultat mis en cache.

Enveloppe de mémorisation de base

Une fermeture contient une table cache. Au premier appel, elle calcule et stocke le résultat. Lors des appels suivants, elle renvoie la valeur stockée.

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 mémorisé

La mémorisation de la fonction récursive de Fibonacci réduit sa complexité temporelle, qui passe d’exponentielle à linéaire.

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

Mémorisation de plusieurs arguments

Pour les fonctions ayant plusieurs arguments, composez une chaîne de clé de cache à partir de tous les arguments.

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

Tables de cache imbriquées

Pour des types d’arguments mixtes, utilisez des tables imbriquées indexées par chaque argument afin d’obtenir une recherche en O(1) sans sérialisation en chaîne.

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

Invalidation du cache

La mémorisation suppose des fonctions pures (sans effets secondaires et produisant la même sortie pour une même entrée). Les fonctions ayant des effets secondaires ne doivent pas être mémorisées sans une invalidation soigneusement gérée du cache.

Mémorisation fondée sur un TTL

Ajoutez une logique de durée de vie à l’aide de os.time() afin d’expirer les entrées mises en 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 à valeurs faibles

Utilisez des valeurs faibles afin que les résultats mis en cache puissent être récupérés par le ramasse-miettes lorsque la mémoire vient à manquer.

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

Modèle de mémorisation récursive

Pour des fonctions mutuellement récursives, affectez l’enveloppe mémorisée avant que le corps récursif ne l’utilise, afin que la récursion passe par le cache.

Cache limité (schéma LRU)

Pour contrôler la mémoire, implémentez un cache LRU qui évince l’entrée la moins récemment utilisée lorsque le cache dépasse une taille maximale.

Mémorisation en pratique

Utilisations courantes : calculs mathématiques coûteux, mise en cache de résultats de requêtes de base de données, compilations de motifs Lua et analyse de fichiers de configuration.

Question sur la mémorisation

Pourquoi la mémorisation doit-elle être appliquée uniquement aux fonctions pures ?

Récapitulatif : mémorisation

La mémorisation utilise un cache conservé par une fermeture pour stocker les résultats selon une clé d’arguments, éliminant ainsi les calculs redondants. Utilisez des tables faibles pour préserver la mémoire et ajoutez un TTL aux caches sensibles au temps.

Questions Fréquemment Posées

La leçon « Mémorisation avec des fermetures » est-elle gratuite ?

Oui — le texte complet de « Mémorisation avec des fermetures » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mémorisation avec des fermetures » ?

Mettez en cache les résultats coûteux d’une fonction dans une table conservée par une fermeture. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Mémorisation avec des fermetures » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Lua Academy