Lua Academy · Les

De functie error()

Genereer fouten met error() en begrijp foutniveaus en foutmeldingen

Les 1 van 412 stappen

De functie error() 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.

Fouten opwerpen

error(message, level) werpt een Lua-fout op. De uitvoering stopt en de fout gaat omhoog door de aanroepstack totdat die wordt opgevangen door pcall of xpcall, of totdat het programma wordt beëindigd. De melding kan elke waarde zijn — een tekenreeks, tabel of getal.

local function divide(a, b)
  if b == 0 then
    error("division by zero")
  end
  return a / b
end

print(divide(10, 2))    -- 5.0
-- divide(10, 0)        -- ERROR: division by zero

Foutniveaus

Het tweede argument van error() bepaalt waar de fout wordt gemeld. Niveau 1 (standaard) verwijst naar de aanroep van error() zelf. Niveau 2 verwijst naar de aanroeper. Niveau 0 voegt geen positie-informatie toe. Gebruik niveau 2 in bibliotheekfuncties om de fout aan de code van de gebruiker toe te schrijven.

local function assertPositive(n, name)
  if n <= 0 then
    error((name or "value") .. " must be positive, got " .. n, 2)
    -- level 2: blame the caller, not this function
  end
  return n
end

local function compute(x)
  assertPositive(x, "x")   -- error points here if x <= 0
  return math.sqrt(x)
end

compute(-5)  -- error: "x must be positive, got -5" at compute() call

Fouten met tabelobjecten

Als je een tabel als foutwaarde doorgeeft, kunnen aanroepers gestructureerde foutinformatie inspecteren: foutcode, melding en context. Dit is informatiever dan een gewone tekenreeks en maakt programmatische foutafhandeling mogelijk.

local function openDB(host, port)
  if port < 1 or port > 65535 then
    error({code="INVALID_PORT", port=port,
           msg="port out of range: " .. port})
  end
  -- ... connect
  return {host=host, port=port}
end

local ok, err = pcall(openDB, "localhost", -1)
if not ok and type(err) == "table" then
  print("Code:", err.code)    -- INVALID_PORT
  print("Port:", err.port)    -- -1
  print("Msg:", err.msg)
end

assert() als verkorte schrijfwijze

assert(v, msg) is gelijkwaardig aan if not v then error(msg, 2) end; return v, .... Dit is de gebruikelijke manier om voorwaarden vooraf te controleren. Als v waarheidsgetrouw is, retourneert assert al zijn argumenten, wat handig is voor het koppelen van aanroepen.

local function sqrt(n)
  assert(type(n) == "number", "expected number, got " .. type(n))
  assert(n >= 0, "sqrt of negative: " .. n)
  return math.sqrt(n)
end

print(sqrt(16))    -- 4.0
print(sqrt(2))     -- 1.4142...
-- sqrt("hi")      -- ERROR: expected number, got string

error() versus return nil,err

Er zijn twee conventies om een mislukking aan te geven: error() (in de stijl van uitzonderingen) of return nil, msg (in de functionele stijl). Gebruik error() voor echt onverwachte omstandigheden, zoals programmeerfouten of contractschendingen. Gebruik nil, msg voor verwachte mislukkingen, zoals een niet gevonden bestand of een time-out van het netwerk.

-- Exception style (programming error)
local function mustExist(t, key)
  local v = t[key]
  if v == nil then error("required key missing: " .. key, 2) end
  return v
end

-- Functional style (expected failure)
local function findUser(id)
  -- ... database query
  return nil, "user not found"  -- expected: user may not exist
end

Fouten in metamethoden

Fouten kunnen binnen metamethoden worden opgeworpen. Als een metamethode een fout veroorzaakt, gaat die door naar de code die de bewerking heeft gestart, zoals een rekenkundige expressie. Bescherm metamethoden altijd tegen ongeldige invoer.

local SafeDiv = {}
SafeDiv.__index = SafeDiv

SafeDiv.__div = function(a, b)
  if b.value == 0 then
    error("SafeDiv: division by zero", 2)
  end
  return SafeDiv.new(a.value / b.value)
end

function SafeDiv.new(v)
  return setmetatable({value=v}, SafeDiv)
end

local a = SafeDiv.new(10)
local b = SafeDiv.new(0)
local ok, err = pcall(function() return a / b end)
print(ok, err)

Aangepaste fouttypen

Maak een helper om getypeerde foutobjecten te bouwen. Voeg een typetag toe, zodat aanroepers onderscheid kunnen maken tussen verschillende soorten fouten en elke fout passend kunnen afhandelen.

local function newError(kind, msg, extra)
  return setmetatable(
    {kind=kind, message=msg, extra=extra},
    {__tostring = function(e)
      return "[" .. e.kind .. "] " .. e.message
    end}
  )
end

local E = {
  notFound = function(name) return newError("NOT_FOUND","not found: "..name) end,
  badInput = function(msg)  return newError("BAD_INPUT", msg) end,
}

local ok, err = pcall(error, E.notFound("config.json"))
if not ok then print(err.kind, err.message) end

Foutpropagatie

Wanneer een functie een andere functie aanroept die een fout veroorzaakt, verspreidt de fout zich automatisch omhoog door de aanroepstack. Je hoeft de fout niet opnieuw te gooien — vang deze gewoon niet af. Vang fouten alleen af op het niveau waarop je ze zinvol kunt afhandelen of rapporteren.

local function step3() error("step3 failed") end
local function step2() step3() end
local function step1() step2() end

local ok, err = pcall(step1)
if not ok then
  -- err includes the source location
  print("Caught at top level:", err)
end
-- Error: input:1: step3 failed

Stacktrace met debug.traceback

Een gewone error() geeft één regel context. Gebruik voor een volledige stacktrace debug.traceback(msg) als foutwaarde. Dit gebeurt meestal in een xpcall-handler.

local function buggy()
  local t = nil
  return t.field   -- nil indexing: error
end

local ok, err = xpcall(buggy, function(e)
  return debug.traceback(e, 2)  -- full stack trace
end)

if not ok then
  print(err)  -- full traceback
end

Fouten opnieuw gooien

Soms vang je een fout af om context toe te voegen en gooi je deze daarna opnieuw. Gebruik error(err, 0) (niveau 0) wanneer je een tekenreeksfout opnieuw gooit, zodat er geen nieuwe locatieprefix wordt toegevoegd aan een al opgemaakt bericht.

local function loadAndParse(path)
  local ok, err = pcall(function()
    local f = io.open(path, "r")
    if not f then error("cannot open: " .. path) end
    local content = f:read("a")
    f:close()
    return content
  end)
  if not ok then
    error("loadAndParse failed: " .. err, 0)  -- re-raise with context
  end
end

local ok2, msg = pcall(loadAndParse, "missing.txt")
print(ok2, msg)

Korte controle

Wat betekent niveau 2 in error("msg", 2)?

Beantwoord dit in de interactieve les

Samenvatting: error()

Samenvatting:

error(msg, level) — gooien; niveau 2 wijst de fout aan de aanroeper toe
Gebruik tabellen voor gestructureerde fouten met een type en context
assert(v, msg) — idiomatische controle van een voorwaarde
Gebruik error() voor bugs; geef nil+err terug voor verwachte fouten
Gooi opnieuw met error(err, 0) om de berichtopmaak te behouden

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 error()” gratis?

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

Genereer fouten met error() en begrijp foutniveaus en foutmeldingen 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 error()”?

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