0Pricing
Lua Academy · Leçon

Éviter les fuites mémoire

Découvrez les motifs courants de fuite en Lua et les stratégies pour les éviter.

Éviter les fuites mémoire 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 qu’une fuite mémoire en Lua ?

Une fuite mémoire se produit lorsque des objets s’accumulent en mémoire parce qu’une référence empêche le GC de les récupérer, alors que le programme n’en a plus besoin.

Fuite courante : accumulation globale

Stocker des objets dans une table globale sans les supprimer est une fuite classique. La table globale est toujours une racine du GC.

local cache = {}  -- global-like upvalue
function storeResult(key, val)
  cache[key] = val  -- never evicted!
end

Correction : cache limité

Limitez la taille du cache et évincez les anciennes entrées à l’aide d’une stratégie LRU ou d’une simple limite de taille.

local MAX = 100
local function boundedStore(cache, key, val)
  if #cache >= MAX then
    table.remove(cache, 1)  -- evict oldest
  end
  cache[key] = val
end

Fuite courante : écouteurs d’événements

Enregistrer une fermeture comme écouteur d’événement et ne jamais la désenregistrer maintient en vie la fermeture ainsi que ses valeurs capturées.

local listeners = {}
function on(event, fn)
  listeners[event] = listeners[event] or {}
  listeners[event][#listeners[event]+1] = fn
end
-- Always provide off() to deregister!

Correction : tables faibles d’écouteurs

Stockez les écouteurs dans une table à valeurs faibles afin que l’écouteur soit automatiquement supprimé lorsque l’objet abonné est récupéré.

local listeners = setmetatable({}, {__mode = "v"})

Fuite courante : fermetures capturant de grandes tables

Une fermeture qui capture une grande table la maintient en vie aussi longtemps que la fermeture existe, même si seule une petite partie de la table est nécessaire.

local bigData = {-- 100MB of data --}
local fn = function()
  return bigData[1]  -- bigData stays alive!
end

Correction : extraire les valeurs nécessaires

Extrayez uniquement les valeurs nécessaires avant de créer la fermeture, afin que la grande table puisse être récupérée.

local needed = bigData[1]
bigData = nil  -- allow collection
local fn = function() return needed end

Fuites liées aux coroutines

Une coroutine suspendue est toujours active et conserve toutes ses variables locales. Les coroutines terminées (état « dead ») peuvent être récupérées. Ne perdez jamais la trace des coroutines suspendues.

Accumulation de chaînes

Concaténer des chaînes dans une boucle avec .. crée de nombreuses chaînes intermédiaires. Utilisez table.concat pour construire efficacement de grandes chaînes.

local parts = {}
for i = 1, 1000 do parts[i] = tostring(i) end
local result = table.concat(parts, ",")

Déboguer les fuites

Utilisez collectgarbage("count") avant et après les opérations pour mesurer l’augmentation de la mémoire. Consignez les augmentations suspectes afin de localiser la source de la fuite.

local before = collectgarbage("count")
-- ... run operation ...
collectgarbage()
local after = collectgarbage("count")
print(("Delta: %.1f KB"):format(after - before))

Outils de profilage

Des outils comme luamemprof et des compteurs d’allocations personnalisés utilisant debug.sethook peuvent déterminer quelles parties du code allouent le plus de mémoire.

Question sur les fuites mémoire

Quel modèle est le plus susceptible de provoquer une fuite mémoire ?

Récapitulatif : éviter les fuites mémoire

Les fuites en Lua proviennent des caches sans limite, des écouteurs non désenregistrés, des fermetures qui englobent de grandes tables et des coroutines suspendues oubliées. Utilisez des tables faibles, des caches limités et collectgarbage("count") pour détecter et prévenir les fuites.

Questions Fréquemment Posées

La leçon « Éviter les fuites mémoire » est-elle gratuite ?

Oui — le texte complet de « Éviter les fuites mémoire » 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 « Éviter les fuites mémoire » ?

Découvrez les motifs courants de fuite en Lua et les stratégies pour les éviter. 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 « Éviter les fuites mémoire » ?

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

  1. Notions de base sur le ramasse-miettes de Lua
  2. Clés faibles et valeurs faibles
  3. Finaliseurs avec __gc
  4. Éviter les fuites mémoire
← Retour à Lua Academy