Lua Academy · Lektion

Die Funktion require

Laden Sie externe Module mit require und verstehen Sie das Caching von Modulen

Die Funktion require ist eine kostenlose Lua Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Lua Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Funktionsweise von require

require(modname) lädt ein Modul und gibt es zurück. Dabei durchsucht es package.path nach einer .lua-Datei und package.cpath nach einer C-Bibliothek. Das Ergebnis wird in package.loaded[modname] zwischengespeichert – nachfolgende Aufrufe geben den zwischengespeicherten Wert zurück, ohne die Datei erneut auszuführen.

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

Rückgabewert eines Moduls

Eine Moduldatei sollte einen Wert zurückgeben – typischerweise eine Tabelle mit Funktionen. Dieser Rückgabewert wird von require an den Aufrufer zurückgegeben. Wenn die Datei nichts (oder true) zurückgibt, gibt require genau diesen Wert zurück.

-- 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 ist eine Tabelle, die Modulnamen ihren geladenen Werten zuordnet. Sie können einen Eintrag manuell setzen, um einen Mock vorzuladen, oder ihn auf nil setzen, um ein erneutes Laden zu erzwingen (die Moduldatei wird beim nächsten require erneut ausgeführt).

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

Format von package.path

package.path ist eine durch Semikolons getrennte Liste von Mustern. Der Platzhalter ? wird durch den Modulnamen ersetzt (wobei Punkte durch Pfadtrenner ersetzt werden). Sie können zu durchsuchende Verzeichnisse hinzufügen, indem Sie sie an den Anfang von package.path setzen.

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 im Vergleich zu dofile und loadfile

require: speichert Ergebnisse zwischen und durchsucht package.path. dofile(path): führt eine Datei sofort aus, speichert nichts zwischen und erwartet einen direkten Pfad. loadfile(path): kompiliert die Datei, führt sie aber nicht aus, sondern gibt eine Funktion zurück. Verwenden Sie require für Module und dofile für einmalige Skripte.

-- 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 mit Punkten für Verzeichnisse

Verwenden Sie Punkte in Modulnamen, um auf Dateien in Unterverzeichnissen zu verweisen. require("utils.string") wird (mit ? im Pfadmuster) auf utils/string.lua abgebildet. So werden Bibliotheken aus mehreren Dateien organisiert.

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

Seiteneffekte bei der Modulinitialisierung

Moduldateien werden beim ersten require-Aufruf einmal ausgeführt. Jeder Code auf oberster Ebene (außerhalb von Funktionen) wird zum Zeitpunkt des require-Aufrufs ausgeführt. Das ist für eine einmalige Initialisierung nützlich, aber seien Sie vorsichtig: Seiteneffekte wie Netzwerkverbindungen oder Dateioperationen werden bereits beim Import ausgeführt.

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

Fehlerbehandlung in require

Wenn eine Moduldatei einen Syntaxfehler enthält oder beim Laden einen Fehler auslöst, löst require ebenfalls einen Fehler aus. Die Fehlermeldung enthält den Modulnamen und den Fehler aus der Datei. Verwenden Sie pcall, um das Fehlschlagen des Modul-Ladevorgangs angemessen zu behandeln.

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 ist eine Tabelle, in der Sie Loader-Funktionen nach Modulnamen registrieren können. Wenn require("name") aufgerufen wird, prüft Lua zuerst den Preload-Speicher. So können Sie Module ohne Dateien registrieren – nützlich für eingebettetes Lua oder 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

Zirkuläres require

Zirkuläre Abhängigkeiten (A benötigt B, B benötigt A) werden teilweise behandelt: Lua speichert vor der Ausführung des Moduls einen Platzhalter true in package.loaded. Wenn B versucht, die noch nicht fertig aufgebaute Tabelle von A zu verwenden, erhält es möglicherweise unvollständige Ergebnisse. Vermeiden Sie zirkuläre Abhängigkeiten beim Entwurf von Modulen.

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

Kurzer Check

Was passiert, wenn Sie require("mod") ein zweites Mal aufrufen?

Zusammenfassung: require

Zusammenfassung:

require(name) lädt nur einmal und speichert das Ergebnis in package.loaded
Die Moduldatei gibt ihre öffentliche Schnittstelle zurück (normalerweise eine Tabelle)
Löschen Sie package.loaded[name], um ein erneutes Laden zu erzwingen
Fügen Sie Einträge zu package.path hinzu, um eigene Suchverzeichnisse zu verwenden
Verwenden Sie package.preload für Module im Speicher
Vermeiden Sie zirkuläre Abhängigkeiten

Häufig gestellte Fragen

Ist die Lektion „Die Funktion require“ kostenlos?

Ja — der vollständige Text von „Die Funktion require“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Lua Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Lua Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Die Funktion require“?

Laden Sie externe Module mit require und verstehen Sie das Caching von Modulen Du übst Lua Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Lua Academy zu starten?

Keine Vorkenntnisse erforderlich. Lua Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Die Funktion require“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Lua Academy-Lektion Code schreiben und ausführen?

Ja. Jede Lua Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Lua Academy