Lua Academy · Leçon

Découverte et chargement de modules d’extension

Parcourez les répertoires à la recherche de fichiers de modules d’extension et chargez-les avec require ou loadfile.

Découverte et chargement de modules d’extension est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 1 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 architecture de plug-ins ?

Une architecture de plug-ins permet à du code tiers d’étendre une application sans modifier son noyau. Les fonctions require et le chargement dynamique de Lua rendent cette approche naturelle.

Découverte des plug-ins par convention

Analysez un répertoire à la recherche de fichiers *.lua correspondant à une convention de nommage, puis chargez chacun d’eux comme un plug-in.

local function discoverPlugins(dir)
  local plugins = {}
  -- platform-specific dir scan; here a mock example
  for _, name in ipairs({"logger", "cache", "auth"}) do
    local ok, mod = pcall(require, dir .. "." .. name)
    if ok then plugins[name] = mod end
  end
  return plugins
end

Utiliser package.path pour la découverte

Étendez package.path afin que require puisse trouver les plug-ins dans un répertoire personnalisé.

package.path = package.path .. ";./plugins/?.lua"
local plugin = require("myplugin")

loadfile pour le chargement dynamique

loadfile(path) compile un fichier Lua en bloc sans l’exécuter. Exécutez-le avec () pour obtenir la table du module du plug-in.

local function loadPlugin(path)
  local chunk, err = loadfile(path)
  if not chunk then return nil, err end
  local ok, result = pcall(chunk)
  if not ok then return nil, result end
  return result
end

Manifeste de plug-in

Chaque plug-in exporte une table de manifeste décrivant son nom, sa version et ses dépendances.

-- plugins/logger.lua
return {
  name    = "logger",
  version = "1.0",
  deps    = {},
  init    = function(app) app:on("log", print) end,
}

Résolution des dépendances

Avant d’initialiser un plug-in, vérifiez que toutes ses dépendances sont déjà chargées.

local function initPlugin(app, plugins, name)
  local p = plugins[name]
  if not p then error("Plugin not found: " .. name) end
  for _, dep in ipairs(p.deps or {}) do
    if not plugins[dep] then
      error(("Plugin %s requires %s"):format(name, dep))
    end
  end
  if p.init then p.init(app) end
end

Rechargement à chaud des plug-ins

Pour recharger un plug-in : supprimez-le de package.loaded, rechargez-le avec require, puis réenregistrez les points d’accroche.

package.loaded["plugins.logger"] = nil
plugins.logger = require("plugins.logger")
plugins.logger.init(app)

Registre des plug-ins

Gérez un registre des plug-ins chargés afin d’éviter les chargements en double et de permettre la vérification des dépendances.

Isolation des erreurs

Chargez les plug-ins avec pcall afin qu’un plug-in défectueux ne fasse pas planter toute l’application.

local ok, err = pcall(function()
  plugins[name] = loadPlugin(path)
  initPlugin(app, plugins, name)
end)
if not ok then
  print("Plugin load failed:", name, err)
end

Métadonnées des plug-ins

Stockez des métadonnées supplémentaires : description, auteur, schéma de configuration. Utilisez-les pour l’affichage dans l’interface ou la configuration automatique.

Chargement différé

Chargez les plug-ins uniquement lorsqu’ils sont nécessaires pour la première fois, plutôt que de les charger dès le démarrage. Implémentez cela au moyen d’une table mandataire dotée d’une métaméthode __index qui déclenche le chargement.

Question sur le chargement des plug-ins

Quel est l’avantage d’utiliser pcall lors du chargement des plug-ins ?

Récapitulatif : découverte et chargement des plug-ins

Découvrez les plug-ins en analysant des répertoires ou en utilisant des conventions de nommage. Chargez-les avec loadfile ou require. Validez les manifestes et résolvez les dépendances. Utilisez toujours pcall pour isoler les échecs de chargement.

Questions Fréquemment Posées

La leçon « Découverte et chargement de modules d’extension » est-elle gratuite ?

Oui — le texte complet de « Découverte et chargement de modules d’extension » 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 « Découverte et chargement de modules d’extension » ?

Parcourez les répertoires à la recherche de fichiers de modules d’extension et chargez-les avec require ou loadfile. 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 1 sur 4.

Combien de temps prend la leçon « Découverte et chargement de modules d’extension » ?

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

Découverte et chargement de modules d’extension
API de modules d’extension et système de hooks
Mettre les modules d’extension en bac à sable
Gestion des versions et des dépendances

← Retour à Lua Academy