Lua Academy · Lektion

Skrivning af en modulfil

Opret et modul ved at returnere en tabel med funktioner fra en .lua-fil.

Lektion 2 af 412 trin

Skrivning af en modulfil er en gratis Lua Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Lua Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Lua Academy-kurset indeholder 4 lektioner i alt.

Det grundlæggende modulmønster

Det almindelige Lua-modulmønster er at oprette en lokal tabel M, føje funktioner og værdier til den og returnere den til sidst. Tabellen er modulets offentlige API. Alle andre lokale værdier i filen er private.

-- 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  "))

Privat tilstand

Variabler, der er erklæret med local i modulfilen, er private – kaldere kan ikke få adgang til dem. Funktioner i modulet kan få adgang til den private tilstand som upvalues. Dette er Lua's mekanisme til indkapsling.

-- 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

Modul med initialisering

Nogle moduler har brug for initialisering (konfiguration, forbindelser). Placér initialiseringskoden på modulniveau (øverst i filen), eller i en eksplicit M.init()-funktion. Tilgangen på modulniveau køres én gang, når modulet kræves første gang; init() kræver et eksplicit kald.

-- 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

Modul med klasse

Et modul kan eksportere en klasse: en tabel med en konstruktørfunktion. Den returnerede modultabel indeholder funktionen new() og kan også fungere som klassens metatabel.

-- 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)

Modulkonstanter

Eksportér konstanter ved at føje dem til modultabellen. Efter konvention skrives konstanter med store bogstaver. Lua har ikke const, så brugere kan teknisk set ændre dem, men navngivning med store bogstaver signalerer »må ikke ændres«.

-- 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

Modulversionering

Medtag et versionsfelt i dit modul. Kaldere kan kontrollere versionen for at sikre kompatibilitet. Brug semantisk versionering (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"))

Undermoduler

Store biblioteker opdeles i undermoduler. Hovedmodulet kan kræve og eksportere undermoduler igen, eller hvert undermodul kan bruges uafhængigt. Organisér filer i mapper, der svarer til modulstien.

-- 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")

Modul med metatabel

Gør et modul kaldeligt ved at give det en metatabel med __call. Det er nyttigt til moduler, der primært består af funktioner, men også har hjælpefunktioner – »hoved«-handlingen er kaldet, og hjælpefunktionerne er felter.

-- 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

Doven indlæsning af undermoduler

Brug __index til at indlæse undermoduler dovent – kun når der første gang anmodes om dem. Det gør opstarten hurtigere for store biblioteker med mange undermoduler.

-- 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(...)

Mønster til modultest

Tilføj en testfunktion eller -blok i bunden af modulfilen, som kun udføres betinget, når filen køres direkte (og ikke kræves). På den måde ligger enhedstestene sammen med koden.

-- 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

Hurtigt tjek

Hvad er den almindelige måde at definere privat tilstand i et Lua-modul på?

Besvar den i den interaktive lektion

Opsummering: Skrivning af moduler

Opsummering:

Mønster: local M = {} ... return M
Lokale værdier i filen = private; M-felter = offentlig API
Kode på modulniveau køres én gang ved den første require
Eksportér klasser via konstruktøren i modultabellen
Doven indlæsning af undermoduler via __index
Medtag _VERSION til kompatibilitetskontroller

Gratis at komme i gang

Lær Lua med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser: 40
Lektioner: 159

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Skrivning af en modulfil” gratis?

Ja — alle 3 lektioner i læringssporet Lua Academy, inklusive “Skrivning af en modulfil”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Lua Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Skrivning af en modulfil”?

Opret et modul ved at returnere en tabel med funktioner fra en .lua-fil. Du øver dig i Lua Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Lua Academy?

Der kræves ingen tidligere erfaring. Lua Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “Skrivning af en modulfil”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Lua Academy-lektion?

Ja. Alle Lua Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

← Tilbage til Lua Academy