Lua Academy · Leçon

Finaliseurs avec __gc

Enregistrez des métaméthodes __gc pour effectuer le nettoyage lors de la collecte des objets.

Finaliseurs avec __gc est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 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’un finaliseur ?

Un finaliseur est une fonction appelée par le GC juste avant la libération d’un objet. En Lua, il est implémenté au moyen de la méthode de métatable __gc dans la métatable d’une table.

Définir un finaliseur

Attachez une fonction __gc à une métatable avant ou au moment de la création de l’objet.

local mt = {
  __gc = function(self)
    print("Finalizing:", self.name)
  end
}
do
  local obj = setmetatable({name = "resource"}, mt)
end
collectgarbage()  -- prints: Finalizing: resource

Motif de nettoyage des ressources

Les finaliseurs sont idéaux pour libérer des ressources externes : des descripteurs de fichiers, des connexions à une base de données ou de la mémoire C.

local function openResource(path)
  local f = io.open(path, "r")
  return setmetatable({handle = f, path = path}, {
    __gc = function(self)
      if self.handle then
        self.handle:close()
        print("Closed:", self.path)
      end
    end
  })
end

Ordre d’exécution des finaliseurs

Les objets dotés de finaliseurs sont récupérés dans l’ordre inverse de leur création. Par défaut, les finaliseurs s’exécutent à raison d’un par cycle du GC.

Résurrection

Si un finaliseur stocke une référence à l’objet (dans une variable globale ou une valeur capturée), l’objet est ressuscité. Il ne recevra qu’un seul autre appel de finaliseur lorsqu’il sera finalement récupéré.

Données utilisateur et __gc

Dans les extensions C, __gc sur des données utilisateur est le principal moyen de libérer la mémoire C. En code Lua pur, les tables utilisent le même mécanisme via les métatables.

Objets proxy pour RAII

Créez une table proxy dont __gc ferme la ressource réelle. Cela reproduit le comportement de RAII en C++.

local function scoped(resource, cleanup)
  return setmetatable({resource}, {
    __gc = function(self) cleanup(self[1]) end
  })
end

Limites des finaliseurs

Les finaliseurs ne doivent pas : appeler des opérations de coroutine, effectuer une suspension, ni supposer un ordre particulier quant à la durée de vie des autres objets. Gardez-les simples et courts.

Tables faibles et finaliseurs

Les objets contenus dans des tables faibles peuvent tout de même être finalisés. Après la finalisation (et une éventuelle résurrection), ils sont entièrement récupérés lors du cycle suivant.

Protection des finaliseurs de toLua

Utilisez un indicateur booléen dans le finaliseur pour éviter un double nettoyage en cas de résurrection.

local mt = {}
mt.__gc = function(self)
  if not self._closed then
    self._closed = true
    -- cleanup...
  end
end

Conseils pratiques

Préférez les méthodes :close() ou :destroy() explicites pour un nettoyage déterministe. Utilisez __gc comme filet de sécurité en cas d’oubli accidentel, et non comme mécanisme principal de gestion des ressources.

Question sur les finaliseurs

Quand la méthode métatable __gc est-elle appelée ?

Récapitulatif : finaliseurs avec __gc

La méthode métatable __gc s’exécute juste avant qu’un objet soit récupéré, ce qui permet un nettoyage des ressources de type RAII. Utilisez-la comme filet de sécurité : préférez les méthodes explicites de fermeture ou de destruction pour une gestion déterministe des ressources.

Questions Fréquemment Posées

La leçon « Finaliseurs avec __gc » est-elle gratuite ?

Oui — le texte complet de « Finaliseurs avec __gc » 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 « Finaliseurs avec __gc » ?

Enregistrez des métaméthodes __gc pour effectuer le nettoyage lors de la collecte des objets. 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 3 sur 4.

Combien de temps prend la leçon « Finaliseurs avec __gc » ?

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

Notions de base sur le ramasse-miettes de Lua
Clés faibles et valeurs faibles
Finaliseurs avec __gc
Éviter les fuites mémoire

← Retour à Lua Academy