Lua Academy · Lektion

Funktionen require

Indlæs eksterne moduler med require, og forstå caching af moduler.

Lektion 1 af 412 trin

Funktionen require er en gratis Lua Academy-lektion på CoddyKit. Dette er lektion 1 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.

Sådan fungerer require

require(modname) indlæser og returnerer et modul. Den søger efter en .lua-fil i package.path og efter et C-bibliotek i package.cpath. Resultatet gemmes i cachen package.loaded[modname] — efterfølgende kald returnerer den cachede værdi uden at køre filen igen.

-- First require: loads and executes math_utils.lua
local math_utils = require("math_utils")

-- Second require: returns cached value (file not re-run)
local math_utils2 = require("math_utils")

print(math_utils == math_utils2)   -- true (same object)
print(package.loaded["math_utils"] == math_utils)  -- true

Modulets returværdi

En modulfil bør returnere en værdi — typisk en tabel med funktioner. Denne returværdi er det, require giver tilbage til kalderen. Hvis filen ikke returnerer noget (eller true), er det dét, require returnerer.

-- mymodule.lua:
-- local M = {}
-- function M.hello() print("Hello from module!") end
-- return M

-- In main script:
local m = require("mymodule")
m.hello()   -- Hello from module!

-- The module table is the interface

Caching i package.loaded

package.loaded er en tabel, der knytter modulnavne til deres indlæste værdier. Du kan manuelt sætte et element for at forhåndsindlæse en mock eller sætte det til nil for at gennemtvinge en genindlæsning (modulfilen køres igen ved næste require).

-- Force reload by clearing cache
package.loaded["mymodule"] = nil
local fresh = require("mymodule")  -- re-executes the file

-- Preload a mock for testing
package.loaded["db"] = {
  query = function() return {} end,
  close = function() end,
}
local db = require("db")  -- gets the mock

Formatet for package.path

package.path er en semikolonadskilt liste af mønstre. Pladsholderen ? erstattes af modulnavnet (hvor punktummer erstattes af sti-separatorer). Du kan tilføje mapper, der skal søges i, ved at sætte dem foran i package.path.

print(package.path)
-- typically: ./?.lua;./?.luac;/usr/share/lua/5.4/?.lua;...

-- Add local lib directory
package.path = "./lib/?.lua;" .. package.path

-- Now require("utils") will look in ./lib/utils.lua

require sammenlignet med dofile og loadfile

require: bruger cache og søger i package.path. dofile(path): kører en fil med det samme, bruger ingen cache og tager en direkte sti. loadfile(path): kompilerer, men kører ikke filen, og returnerer en funktion. Brug require til moduler og dofile til engangsscripts.

-- dofile: no caching, direct path
dofile("./scripts/setup.lua")

-- loadfile: compile only, returns function
local fn, err = loadfile("./config.lua")
if fn then
  local result = fn()   -- execute when ready
end

-- require: best for modules
local json = require("json")

require med punktummer til mapper

Brug punktummer i modulnavne til at referere til filer i undermapper. require("utils.string") svarer til utils/string.lua (med ? i stimønsteret). Sådan organiseres biblioteker med flere filer.

-- Directory structure:
-- lib/
--   utils/
--     string.lua
--     table.lua
--   init.lua

package.path = "./lib/?.lua;" .. package.path

local strUtils = require("utils.string")   -- loads lib/utils/string.lua
local tblUtils = require("utils.table")    -- loads lib/utils/table.lua

Bivirkninger ved modulinitialisering

Modulfiler køres én gang, første gang de kræves. Al kode på øverste niveau (uden for funktioner) kører på require-tidspunktet. Det er nyttigt til engangsinitialisering, men vær forsigtig — bivirkninger som netværksforbindelser eller filhandlinger kører på indlæsningstidspunktet.

-- counter.lua:
-- local count = 0   -- initialized once on first require
-- local M = {}
-- function M.increment() count = count + 1 end
-- function M.get() return count end
-- return M

local c = require("counter")
c.increment()
c.increment()
print(c.get())   -- 2

local c2 = require("counter")
print(c2.get())  -- 2 (same instance, cached)

Fejlhåndtering i require

Hvis en modulfil indeholder en syntaksfejl eller giver en fejl under indlæsningen, kaster require en fejl. Fejlmeddelelsen indeholder modulnavnet og fejlen fra filen. Brug pcall til at håndtere fejl ved modulindlæsning på en hensigtsmæssig måde.

local ok, mod = pcall(require, "possibly_missing")
if not ok then
  print("Module not available:", mod)
  -- fall back to alternative or default implementation
  mod = {feature = function() return "fallback" end}
end

print(mod.feature())

package.preload

package.preload er en tabel, hvor du kan registrere indlæsningsfunktioner efter modulnavn. Når require("name") kaldes, tjekker Lua først preload. Det lader dig registrere moduler uden filer – nyttigt til indlejret Lua eller test.

package.preload["mymath"] = function()
  return {
    double = function(n) return n * 2 end,
    triple = function(n) return n * 3 end,
  }
end

local m = require("mymath")
print(m.double(5))   -- 10
print(m.triple(5))   -- 15

Cirkulær require

Cirkulære afhængigheder (A kræver B, B kræver A) håndteres delvist: Lua gemmer en true-pladsholder i package.loaded, før modulet udføres. Hvis B forsøger at bruge A's ufærdige tabel, kan det få ufuldstændige resultater. Undgå cirkulære afhængigheder i moduldesignet.

-- a.lua: local b = require("b"); local M = {}; M.name = "A"; return M
-- b.lua: local a = require("a"); print("a.name:", a.name); return {}

-- When a.lua is loaded:
-- 1. a starts executing
-- 2. requires b -> b starts executing
-- 3. b requires a -> gets partial a (still loading!)
-- 4. a.name may be nil at step 3

print("Avoid circular requires in module design")

Hurtigt tjek

Hvad sker der, når du kalder require("mod") for anden gang?

Besvar den i den interaktive lektion

Opsummering: require

Opsummering:

require(name) indlæser én gang og gemmer resultatet i package.loaded
Modulfilen returnerer sin offentlige grænseflade (som regel en tabel)
Ryd package.loaded[name] for at gennemtvinge en genindlæsning
Føj til package.path for at tilføje brugerdefinerede søgemapper
Brug package.preload til moduler i hukommelsen
Undgå cirkulære afhængigheder

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 “Funktionen require” gratis?

Ja — alle 3 lektioner i læringssporet Lua Academy, inklusive “Funktionen require”, 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 “Funktionen require”?

Indlæs eksterne moduler med require, og forstå caching af moduler. 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 1 af 4.

Hvor lang tid tager lektionen “Funktionen require”?

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