Lua Academy · Les

Een modulebestand schrijven

Maak een module door vanuit een .lua-bestand een table met functies te retourneren

Les 2 van 412 stappen

Een modulebestand schrijven is een gratis Lua Academy-les op CoddyKit. Dit is les 2 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.

Het basispatroon voor modules

Het standaardmodulepatroon in Lua: maak een lokale tabel M, voeg er functies en waarden aan toe en geef de tabel aan het einde terug. De tabel is de openbare programmeerinterface van de module. Alle andere lokale waarden in het bestand zijn privé.

-- stringutils.lua
local M = {}

function M.trim(s)
  return s:match("^%s*(.-)%s*$")
end

function M.split(s, sep)
  local t = {}
  for p in s:gmatch("[^"..sep.."]+") do t[#t+1]=p end
  return t
end

return M

-- Usage:
-- local su = require("stringutils")
-- print(su.trim("  hello  "))

Privéstatus

Variabelen die in het modulebestand als local zijn gedeclareerd, zijn privé — aanroepers kunnen er niet bij. Functies in de module kunnen via upvalues toegang krijgen tot de privéstatus. Dit is het mechanisme voor inkapseling in Lua.

-- counter.lua
local M = {}
local count = 0   -- private state

function M.increment(n)
  count = count + (n or 1)
end

function M.reset()
  count = 0
end

function M.get()
  return count
end

return M

Module met initialisatie

Sommige modules hebben initialisatie nodig (configuratie, verbindingen). Plaats initialisatiecode op moduleniveau (bovenaan het bestand) of in een expliciete functie M.init(). De aanpak op moduleniveau wordt één keer uitgevoerd wanneer de module voor het eerst wordt vereist; voor init() is een expliciete aanroep nodig.

-- cache.lua
local M = {}
local store = {}   -- initialized at load time
local hits = 0
local misses = 0

function M.get(key)
  if store[key] ~= nil then
    hits = hits + 1
    return store[key]
  end
  misses = misses + 1
  return nil
end

function M.set(key, val) store[key] = val end
function M.stats() return {hits=hits, misses=misses} end

return M

Module met klasse

Een module kan een klasse exporteren: een tabel met een constructorfunctie. De teruggegeven moduletabel bevat de functie new() en kan ook dienstdoen als metatabel van de klasse.

-- point.lua
local Point = {}
Point.__index = Point

function Point.new(x, y)
  return setmetatable({x=x, y=y}, Point)
end

function Point:distance(other)
  local dx, dy = self.x-other.x, self.y-other.y
  return math.sqrt(dx*dx + dy*dy)
end

function Point:__tostring()
  return string.format("(%g,%g)", self.x, self.y)
end

return Point

-- Usage:
-- local Point = require("point")
-- local p = Point.new(3, 4)

Moduleconstanten

Exporteer constanten door ze aan de moduletabel toe te voegen. Volgens de conventie schrijf je constanten in hoofdletters. Omdat Lua geen const heeft, kunnen gebruikers ze technisch gezien wijzigen, maar de naamgeving in hoofdletters geeft aan: "niet wijzigen".

-- colors.lua
local M = {}

M.RED   = {r=255, g=0,   b=0}
M.GREEN = {r=0,   g=255, b=0}
M.BLUE  = {r=0,   g=0,   b=255}
M.WHITE = {r=255, g=255, b=255}
M.BLACK = {r=0,   g=0,   b=0}

function M.toHex(c)
  return string.format("#%02X%02X%02X", c.r, c.g, c.b)
end

return M

Versiebeheer van modules

Neem een versiewaarde op in je module. Aanroepers kunnen de versie controleren om compatibiliteit te garanderen. Gebruik semantische versiebeheer (major.minor.patch).

-- mylib.lua
local M = {}
M._VERSION = "1.2.3"
M._NAME = "mylib"
M._DESCRIPTION = "My Lua library"

function M.hello(name)
  return "Hello, " .. (name or "World") .. "!"
end

return M

-- Usage:
local mylib = require("mylib")
print(mylib._VERSION)   -- 1.2.3
print(mylib.hello("Lua"))

Submodules

Grote bibliotheken worden opgesplitst in submodules. De hoofdmodule kan submodules vereisen en opnieuw exporteren, of elke submodule wordt onafhankelijk gebruikt. Orden bestanden in mappen die overeenkomen met het modulepad.

-- mylib/init.lua  (loaded by require("mylib"))
local M = {}

M.strings = require("mylib.strings")
M.tables  = require("mylib.tables")
M.math    = require("mylib.math")

M._VERSION = "2.0.0"

return M

-- Users can require the whole library:
-- local mylib = require("mylib")
-- mylib.strings.trim(...)

-- Or individual sub-modules:
-- local strs = require("mylib.strings")

Module met metatabel

Maak een module aanroepbaar door hem een metatabel met __call te geven. Dit is handig voor modules die voornamelijk uit functies bestaan maar ook hulpprogramma's hebben — de "hoofd"bewerking is de aanroep en de hulpprogramma's zijn velden.

-- format.lua
local M = {}
setmetatable(M, {__call = function(_, fmt, ...)
  return string.format(fmt, ...)
end})

function M.pad(s, width, char)
  char = char or " "
  return string.rep(char, math.max(0, width - #s)) .. s
end

return M

-- Usage:
-- local fmt = require("format")
-- print(fmt("%.2f", 3.14))   -- 3.14
-- print(fmt.pad("42", 5))    --    42

Submodules lui laden

Gebruik __index om submodules lui te laden — alleen wanneer ze voor het eerst worden gebruikt. Dit versnelt het opstarten van grote bibliotheken met veel submodules.

-- biglib.lua
local M = {}
local submodules = {"strings", "tables", "math", "io"}

setmetatable(M, {
  __index = function(t, k)
    for _, name in ipairs(submodules) do
      if name == k then
        local mod = require("biglib." .. k)
        rawset(t, k, mod)
        return mod
      end
    end
    return nil
  end
})

return M

-- Loads biglib.strings only when accessed:
-- local lib = require("biglib")
-- lib.strings.trim(...)

Patroon voor moduletests

Voeg onderaan het modulebestand een testfunctie of testblok toe die alleen voorwaardelijk wordt uitgevoerd wanneer het bestand rechtstreeks wordt uitgevoerd (en niet wordt vereist). Zo blijven unittests bij de bijbehorende code staan.

-- utils.lua
local M = {}

function M.clamp(v, lo, hi)
  return math.max(lo, math.min(hi, v))
end

-- Self-test: only runs when executed directly
if debug.getinfo(2, "S") == nil then
  -- Running as main script, not required
  print("Testing clamp...")
  assert(M.clamp(5, 0, 10) == 5)
  assert(M.clamp(-1, 0, 10) == 0)
  assert(M.clamp(15, 0, 10) == 10)
  print("All tests passed!")
end

return M

Korte controle

Wat is de standaardmanier om een privéstatus in een Lua-module te definiëren?

Beantwoord dit in de interactieve les

Samenvatting: modules schrijven

Samenvatting:

Patroon: local M = {} ... return M
Lokale waarden in het bestand = privé; velden van M = openbare programmeerinterface
Code op moduleniveau wordt één keer uitgevoerd bij de eerste require
Exporteer klassen via een constructor in de moduletabel
Laad submodules lui via __index
Neem _VERSION op voor compatibiliteitscontroles

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 “Een modulebestand schrijven” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Een modulebestand schrijven”, 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 “Een modulebestand schrijven”?

Maak een module door vanuit een .lua-bestand een table met functies te retourneren 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 2 van 4.

Hoe lang duurt de les “Een modulebestand schrijven”?

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