Lua Academy · Les

De functie require

Laad externe modules met require en begrijp caching van modules

Les 1 van 412 stappen

De functie require 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.

Hoe require werkt

require(modname) laadt een module en geeft deze terug. Er wordt in package.path gezocht naar een .lua-bestand en in package.cpath naar een C-bibliotheek. Het resultaat wordt opgeslagen in de cache in package.loaded[modname] — bij volgende aanroepen wordt de waarde uit de cache teruggegeven zonder het bestand opnieuw uit te voeren.

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

Retourwaarde van een module

Een modulebestand moet een waarde teruggeven — meestal een tabel met functies. Deze retourwaarde geeft require door aan de aanroeper. Als het bestand niets (of true) teruggeeft, geeft require dat terug.

-- 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 in package.loaded

package.loaded is een tabel die modulenamen aan hun geladen waarden koppelt. Je kunt handmatig een item instellen om vooraf een nepobject te laden, of het instellen op nil om opnieuw laden af te dwingen (het modulebestand wordt bij de volgende require opnieuw uitgevoerd).

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

Indeling van package.path

package.path is een door puntkomma's gescheiden lijst met patronen. De plaatshouder ? wordt vervangen door de modulenaam (waarbij punten worden vervangen door padscheidingstekens). Je kunt mappen aan de zoekopdracht toevoegen door ze vooraan aan package.path toe te voegen.

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 versus dofile versus loadfile

require: gebruikt caching en zoekt in package.path. dofile(path): voert een bestand onmiddellijk uit, zonder caching, en gebruikt een direct pad. loadfile(path): compileert maar voert niet uit en geeft een functie terug. Gebruik require voor modules en dofile voor eenmalige scripts.

-- 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 met punten voor mappen

Gebruik punten in modulenamen om naar bestanden in submappen te verwijzen. require("utils.string") wordt omgezet naar utils/string.lua (met ? in het padpatroon). Zo worden bibliotheken met meerdere bestanden georganiseerd.

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

Bijwerkingen van module-initialisatie

Modulebestanden worden één keer uitgevoerd wanneer ze voor het eerst worden vereist. Code op het hoogste niveau (buiten functies) wordt tijdens require uitgevoerd. Dit is nuttig voor eenmalige initialisatie, maar wees voorzichtig — bijwerkingen zoals netwerkverbindingen of bestandsbewerkingen worden tijdens het importeren uitgevoerd.

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

Foutafhandeling in require

Als een modulebestand een syntaxisfout bevat of tijdens het laden een fout veroorzaakt, gooit require een fout. Het foutbericht bevat de modulenaam en de fout uit het bestand. Gebruik pcall om mislukkingen bij het laden van modules netjes af te handelen.

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 is een tabel waarin je laadfuncties op modulisnaam kunt registreren. Wanneer require("name") wordt aangeroepen, controleert Lua eerst preload. Zo kun je modules registreren zonder bestanden — handig voor ingebedde Lua of tests.

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

Circulaire require

Circulaire afhankelijkheden (A vereist B, B vereist A) worden gedeeltelijk afgehandeld: Lua slaat een tijdelijke waarde true op in package.loaded voordat de module wordt uitgevoerd. Als B de onvoltooide tabel van A probeert te gebruiken, kan het onvolledige resultaten krijgen. Vermijd circulaire afhankelijkheden in het moduleontwerp.

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

Korte controle

Wat gebeurt er wanneer je require("mod") een tweede keer aanroept?

Beantwoord dit in de interactieve les

Samenvatting: require

Samenvatting:

require(name) laadt één keer en slaat de module op in package.loaded
Het modulebestand geeft zijn openbare interface terug (meestal een tabel)
Maak package.loaded[name] leeg om opnieuw laden af te dwingen
Voeg mappen toe aan package.path voor aangepaste zoekmappen
Gebruik package.preload voor modules in het geheugen
Vermijd circulaire afhankelijkheden

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

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

Laad externe modules met require en begrijp caching van modules 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 “De functie require”?

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