Lua Academy · Lektion

Modulmønstre og bedste praksis

Brug mønstret local M = {}, og eksponér den offentlige API klart.

Lektion 4 af 412 trin

Modulmønstre og bedste praksis er en gratis Lua Academy-lektion på CoddyKit. Dette er lektion 4 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.

Mønsteret M = {}

Det universelle Lua-modulmønster: erklær en lokal tabel, udfyld den, og returnér den. Alle offentlige symboler placeres i M; alle private hjælpefunktioner er almindelige lokale værdier. Det er tydeligt, minimalistisk og fungerer overalt.

-- The canonical module pattern
local M = {}

-- Private helper (not exported)
local function validate(x)
  return type(x) == "number" and x >= 0
end

-- Public API
function M.sqrt(x)
  assert(validate(x), "expected non-negative number")
  return math.sqrt(x)
end

M.PI = math.pi

return M

Selvrefererende modul

Inde i et modul kan funktioner kalde andre modulfunktioner enten via navn (M.foo()) eller som lokale værdier. Det er en smule hurtigere at bruge lokale værdier; med M.foo() kan brugere tilsidesætte M.foo, så det interne kald bruger tilsidesættelsen (monkey patching).

local M = {}

-- Option A: use M.foo inside (allows override)
function M.double(n) return M.multiply(n, 2) end
function M.multiply(a, b) return a * b end

-- Option B: use local function (faster, no override)
local function mul(a, b) return a * b end
function M.triple(n) return mul(n, 3) end

return M

Singleton-mønster

Et modul kan fungere som en singleton: det har en ændringsbar intern tilstand, der deles af alle kaldere. Da require gemmer modulet i cachen, får alle kald til require("mod") det samme objekt med den samme tilstand.

-- config.lua (singleton)
local M = {}
local _config = {env="dev", logLevel="info"}

function M.set(key, val)
  _config[key] = val
end

function M.get(key)
  return _config[key]
end

function M.load(t)
  for k,v in pairs(t) do _config[k]=v end
end

return M

-- All callers share the same config:

Modul som navnerum

Brug et modul udelukkende som navnerum for at undgå at forurene den globale tabel. Gruppér relaterede konstanter og hjælpefunktioner under ét navn, ligesom en pakke i andre sprog.

-- constants.lua
local M = {
  HTTP = {
    OK=200, CREATED=201, NO_CONTENT=204,
    BAD_REQUEST=400, UNAUTHORIZED=401,
    NOT_FOUND=404, SERVER_ERROR=500,
  },
  COLORS = {RED="#FF0000", GREEN="#00FF00", BLUE="#0000FF"},
  MAX_RETRIES = 3,
  TIMEOUT_SEC = 30,
}
return M

-- local C = require("constants")
-- if status == C.HTTP.NOT_FOUND then ...

Fabrikmodul

Et modul, der eksporterer en fabriksfunktion i stedet for en almindelig tabel. Fabrikken opretter og returnerer nye instanser med deres egen private tilstand. Dette er klassemønsteret på modulniveau.

-- logger.lua
local M = {}

function M.new(name, level)
  level = level or "info"
  local levels = {debug=1,info=2,warn=3,error=4}
  local self = {}
  
  function self.log(msgLevel, msg)
    if levels[msgLevel] >= levels[level] then
      print(string.format("[%s][%s] %s", name, msgLevel:upper(), msg))
    end
  end
  
  function self.info(msg)  self.log("info",  msg) end
  function self.warn(msg)  self.log("warn",  msg) end
  function self.error(msg) self.log("error", msg) end
  
  return self
end

return M

Modulets init-funktion

Nogle moduler kræver konfiguration før brug. Angiv en M.init(config)-funktion, der gemmer konfigurationen i modulets private tilstand. Det muliggør afhængighedsinjektion og gør test lettere.

-- db.lua
local M = {}
local pool = nil

function M.init(config)
  pool = {
    host = config.host or "localhost",
    port = config.port or 5432,
    connections = {},
  }
  print("DB initialized:", pool.host, pool.port)
end

function M.query(sql)
  assert(pool, "call db.init() first")
  -- ... execute query
  return {}
end

return M

Uforanderligt modul

Forhindr brugere i ved et uheld at ændre modulets API ved at bruge __newindex til at blokere alle skrivninger. Det er især nyttigt til biblioteksmoduler, hvor utilsigtet monkey patching kan ødelægge funktionaliteten.

local function freeze(t)
  return setmetatable({}, {
    __index = t,
    __newindex = function(_, k, _)
      error("module is read-only, cannot set: " .. tostring(k), 2)
    end
  })
end

local M = {}
function M.add(a, b) return a + b end
function M.sub(a, b) return a - b end

return freeze(M)

Dokumentation med LDoc

En almindelig konvention til dokumentation af Lua-moduler er kommentarer i LDoc-stil med præfikset ---. Selvom sproget ikke håndhæver dette, gør kommentarerne det muligt for værktøjer til generering af dokumentation automatisk at oprette API-dokumentation.

--- A utility module for string operations.
-- @module stringutils
local M = {}

--- Trim leading and trailing whitespace.
-- @param s string The input string.
-- @return string The trimmed string.
function M.trim(s)
  return s:match("^%s*(.-)%s*$")
end

--- Count occurrences of a substring.
-- @param str string The string to search.
-- @param sub string The substring to count.
-- @return number Count of occurrences.
function M.count(str, sub)
  local _, n = str:gsub(sub, "")
  return n
end

return M

Test af moduler

Test et modul ved at kræve det og afprøve hver funktion. Brug en simpel testrunner eller busted (Lua-testrammeværket). Opbevar testene i en separat fil, der spejler modulets sti.

-- test/test_stringutils.lua
local su = require("stringutils")

local function test(name, fn)
  local ok, err = pcall(fn)
  if ok then print("[PASS] " .. name)
  else   print("[FAIL] " .. name .. ": " .. err)
  end
end

test("trim removes spaces", function()
  assert(su.trim("  hello  ") == "hello")
end)

test("trim empty string", function()
  assert(su.trim("") == "")
end)

test("count occurrences", function()
  assert(su.count("banana", "a") == 3)
end)

Sammensætning af moduler

Komplekse systemer sammensættes af flere moduler. Et hovedindgangspunkt kræver undermodulerne og forbinder dem. Denne opdeling af ansvar holder hvert modul fokuseret og gør det muligt at teste dem uafhængigt.

-- app.lua (main entry point)
local config = require("config")
local db     = require("db")
local server = require("server")

-- Configure from environment
config.load({
  dbHost = os.getenv("DB_HOST") or "localhost",
  port   = tonumber(os.getenv("PORT")) or 8080,
})

-- Wire modules together
db.init({host=config.get("dbHost"), port=5432})
server.init({port=config.get("port"), db=db})
server.start()

Hurtigt tjek

Hvad er hovedformålet med modulmønsteret local M = {} ... return M?

Besvar den i den interaktive lektion

Opsummering: Bedste praksis for moduler

Opsummering:

Brug altid local M = {} ... return M
Private = lokale værdier på filniveau; offentlige = M-felter
Singleton: require gemmer modulinstansen i cachen
Brug fabriksfunktioner til tilstand pr. instans
Frys moduler med __newindex for at forhindre ændringer
Test i separate filer; dokumentér med ----kommentarer

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 “Modulmønstre og bedste praksis” gratis?

Ja — alle 3 lektioner i læringssporet Lua Academy, inklusive “Modulmønstre og bedste praksis”, 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 “Modulmønstre og bedste praksis”?

Brug mønstret local M = {}, og eksponér den offentlige API klart. 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 4 af 4.

Hvor lang tid tager lektionen “Modulmønstre og bedste praksis”?

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