Lua Academy · Les

Plugins ontdekken en laden

Doorzoek mappen naar pluginbestanden en laad ze met require of loadfile

Les 1 van 413 stappen

Plugins ontdekken en laden is een gratis Lua Academy-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Wat is een plug-inarchitectuur?

Met een plug-inarchitectuur kan code van derden een toepassing uitbreiden zonder de kern ervan te wijzigen. Lua's require en dynamisch laden maken dit vanzelfsprekend.

Plug-ins ontdekken op basis van conventies

Doorzoek een map naar *.lua-bestanden die aan een naamgevingsconventie voldoen en laad elk bestand vervolgens als 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

package.path gebruiken voor ontdekking

Breid package.path uit zodat require plug-ins in een aangepaste map kan vinden.

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

loadfile voor dynamisch laden

loadfile(path) compileert een Lua-bestand naar een chunk zonder het uit te voeren. Voer de chunk uit met () om de moduletabel van de plug-in te verkrijgen.

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

Plug-inmanifest

Elke plug-in exporteert een manifesttabel met de naam, versie en afhankelijkheden ervan.

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

Afhankelijkheden oplossen

Controleer voordat je een plug-in initialiseert of al zijn afhankelijkheden zijn geladen.

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

Plug-ins tijdens runtime opnieuw laden

Een plug-in opnieuw laden: verwijder deze uit package.loaded, laad opnieuw met require en registreer hooks opnieuw.

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

Plug-inregister

Houd een register bij van geladen plug-ins om dubbel laden te voorkomen en afhankelijkheden te kunnen controleren.

Foutisolatie

Laad plug-ins met pcall, zodat een defecte plug-in niet de hele toepassing laat crashen.

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

Plug-inmetagegevens

Sla aanvullende metagegevens op: beschrijving, auteur en configuratieschema. Gebruik deze voor weergave in de gebruikersinterface of automatische configuratie.

Lui laden

Laad plug-ins pas wanneer ze voor het eerst nodig zijn, in plaats van ze bij het opstarten meteen te laden. Implementeer dit via een proxytabel met een __index-metamethode die het laden start.

Vraag over het laden van plug-ins

Wat is het voordeel van pcall gebruiken bij het laden van plug-ins?

Beantwoord dit in de interactieve les

Samenvatting: plug-ins ontdekken en laden

Ontdek plug-ins door mappen te doorzoeken of naamgevingsconventies te gebruiken. Laad ze met loadfile of require. Valideer manifesten en los afhankelijkheden op. Gebruik altijd pcall om laadfouten te isoleren.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Plugins ontdekken en laden” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Plugins ontdekken en laden”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Plugins ontdekken en laden”?

Doorzoek mappen naar pluginbestanden en laad ze met require of loadfile Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 1 van 4.

Hoe lang duurt de les “Plugins ontdekken en laden”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Lua Academy