Lua Academy · Lektion

Funktionen error()

Udløs fejl med error(), og forstå fejlniveauer og fejlmeddelelser.

Lektion 1 af 412 trin

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

Udløsning af fejl

error(message, level) udløser en Lua-fejl. Udførelsen stopper, og fejlen bevæger sig op gennem kaldestakken, indtil den fanges af pcall eller xpcall, eller indtil programmet afsluttes. Meddelelsen kan være en vilkårlig værdi — streng, tabel eller tal.

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

Fejlniveauer

Det andet argument til error() styrer, hvor fejlen rapporteres. Niveau 1 (standard) peger på selve kaldet til error(). Niveau 2 peger på den kaldende kode. Niveau 0 tilføjer ingen positionsoplysninger. Brug niveau 2 i biblioteksfunktioner for at pege på brugerens kode som årsag.

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

Fejl med tabelobjekter

Hvis du sender en tabel som fejlværdi, kan den kaldende kode undersøge strukturerede fejloplysninger: fejlkode, meddelelse og kontekst. Det er mere informativt end en almindelig streng og muliggør programmatisk fejlhåndtering.

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() som syntaktisk sukker

assert(v, msg) svarer til if not v then error(msg, 2) end; return v, .... Det er idiomatisk til kontrol af forudsætninger. Hvis v er sandhedsværdi, returnerer assert alle sine argumenter (hvilket er nyttigt ved kædning).

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() kontra return nil,err

Der er to konventioner til at signalere fejl: error() (undtagelsesstil) eller return nil, msg (funktionel stil). Brug error() ved reelt uventede forhold (programmeringsfejl, brud på kontrakter). Brug nil, msg ved forventelige fejl (filen blev ikke fundet, timeout på netværket).

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

Fejl i metametoder

Fejl kan udløses inde i metametoder. Hvis en metametode giver en fejl, videreføres den til den kode, der udløste handlingen (f.eks. et aritmetisk udtryk). Kontrollér altid for ugyldigt input i metametoder.

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)

Brugerdefinerede fejltyper

Opret en hjælper til at bygge typede fejlobjekter. Inkluder et typemærke, så kaldere kan skelne mellem forskellige slags fejl og håndtere hver af dem korrekt.

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

Fejlpropagering

Når en funktion kalder en anden funktion, der giver en fejl, propagerer fejlen automatisk op gennem stakken. Du behøver ikke kaste den igen — lad blot være med at fange den. Fang kun fejl på det niveau, hvor du meningsfuldt kan håndtere eller rapportere dem.

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

Stakspor med debug.traceback

Et almindeligt error() giver én linje med kontekst. Brug debug.traceback(msg) som fejlværdi for at få et komplet stakspor. Det gøres typisk i en 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

Fejl, der kastes igen

Nogle gange fanger du en fejl for at tilføje kontekst og kaster den derefter igen. Brug error(err, 0) (niveau 0), når du kaster en strengfejl igen, så der ikke tilføjes endnu et placeringspræfiks til en allerede formateret meddelelse.

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)

Hurtigt tjek

Hvad betyder niveau 2 i error("msg", 2)?

Besvar den i den interaktive lektion

Opsummering: error()

Opsummering:

error(msg, level) — kaster en fejl; niveau 2 angiver kaldere som årsag
Brug tabeller til strukturerede fejl med type og kontekst
assert(v, msg) — idiomatisk tjek af en forudsætning
Brug error() til fejl i programmet; returnér nil+err ved forventede fejl
Kast igen med error(err, 0) for at bevare meddelelsesformatet

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

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

Udløs fejl med error(), og forstå fejlniveauer og fejlmeddelelser. 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 error()”?

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