Lua Academy · Lezione

Individuazione e caricamento dei plugin

Analizzi le directory alla ricerca di file di plugin e li carichi con require o loadfile.

Individuazione e caricamento dei plugin è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Che cos'è un'architettura a plugin?

Un'architettura a plugin consente al codice di terze parti di estendere un'applicazione senza modificarne il nucleo. require e il caricamento dinamico di Lua rendono naturale questo approccio.

Rilevamento dei plugin per convenzione

Esegua la scansione di una directory alla ricerca di file *.lua che rispettano una convenzione di denominazione, quindi carichi ciascun file come plugin.

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

Utilizzo di package.path per il rilevamento

Estenda package.path affinché require possa trovare i plugin in una directory personalizzata.

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

loadfile per il caricamento dinamico

loadfile(path) compila un file Lua in un chunk senza eseguirlo. Lo esegua con () per ottenere la tabella del modulo del plugin.

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

Manifest del plugin

Ogni plugin esporta una tabella manifest che descrive il proprio nome, la versione e le dipendenze.

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

Risoluzione delle dipendenze

Prima di inizializzare un plugin, verifichi che tutte le sue dipendenze siano già state caricate.

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

Hot reloading dei plugin

Per ricaricare un plugin: lo rimuova da package.loaded, lo ricarichi con require e registri nuovamente gli hook.

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

Registro dei plugin

Mantenga un registro dei plugin caricati per evitare caricamenti duplicati e consentire il controllo delle dipendenze.

Isolamento degli errori

Carichi i plugin con pcall, in modo che un plugin difettoso non arresti l'intera applicazione.

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

Metadati dei plugin

Memorizzi metadati aggiuntivi: descrizione, autore, schema di configurazione. Li utilizzi per la visualizzazione nell'interfaccia o per la configurazione automatica.

Caricamento lazy

Carichi i plugin solo quando sono necessari per la prima volta, invece di caricarli subito all'avvio. Implementi questa tecnica tramite una tabella proxy con un metamethod __index che attiva il caricamento.

Domanda sul caricamento dei plugin

Qual è il vantaggio di utilizzare pcall durante il caricamento dei plugin?

Riepilogo: rilevamento e caricamento dei plugin

Rilevi i plugin eseguendo la scansione delle directory o utilizzando convenzioni di denominazione. Li carichi con loadfile o require. Convalidi i manifest e risolva le dipendenze. Utilizzi sempre pcall per isolare gli errori di caricamento.

Domande Frequenti

La lezione «Individuazione e caricamento dei plugin» è gratuita?

Sì — il testo completo di «Individuazione e caricamento dei plugin» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Individuazione e caricamento dei plugin»?

Analizzi le directory alla ricerca di file di plugin e li carichi con require o loadfile. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Individuazione e caricamento dei plugin»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

Individuazione e caricamento dei plugin
API dei plugin e sistema degli hook
Sandbox per l'esecuzione dei plugin
Versionamento e gestione delle dipendenze

← Torna a Lua Academy