Lua Academy · Lektion

Funktionen error()

Generera fel med error() och förstå felnivåer och felmeddelanden.

Lektion 1 av 412 steg

Funktionen error() är en gratis lektion i Lua Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Lua Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Lua Academy innehåller totalt 4 lektioner.

Kasta fel

error(message, level) utlöser ett Lua-fel. Körningen stoppas och felet fortplantas upp genom anropsstacken tills det fångas av pcall eller xpcall, eller tills programmet avslutas. Meddelandet kan vara vilket värde som helst – en sträng, tabell eller ett 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

Felnivåer

Det andra argumentet till error() styr var felet rapporteras. Nivå 1 (standard) pekar på själva anropet av error(). Nivå 2 pekar på anroparen. Nivå 0 lägger inte till någon positionsinformation. Använd nivå 2 i biblioteksfunktioner för att ange att felet ligger i användarens kod.

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

Fel med tabellobjekt

Genom att skicka en tabell som felvärde kan anroparen inspektera strukturerad felinformation: felkod, meddelande och kontext. Detta är mer informativt än en vanlig sträng och möjliggör programmatisk felhantering.

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 förenkling

assert(v, msg) motsvarar if not v then error(msg, 2) end; return v, .... Det är idiomatiskt för kontroll av förvillkor. Om v är truthy returnerar assert alla sina argument, vilket är användbart vid kedjning.

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() jämfört med return nil,err

Det finns två konventioner för att signalera fel: error() i exception-stil eller return nil, msg i funktionell stil. Använd error() för verkligt oväntade tillstånd, till exempel programmeringsfel och avtalsbrott. Använd nil, msg för förväntade fel, till exempel att en fil saknas eller att en nätverksbegäran tar slut på tid.

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

Fel i metametoder

Fel kan utlösas inuti metametoder. Om en metametod orsakar ett fel fortplantas det till koden som utlöste operationen, till exempel ett aritmetiskt uttryck. Skydda alltid metametoder mot ogiltiga indata.

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)

Anpassade feltyper

Skapa en hjälpfunktion för att skapa typade felobjekt. Inkludera en typetikett så att anropande kod kan skilja mellan olika typer av fel och hantera varje typ på rätt sätt.

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

Felpropagering

När en funktion anropar en annan funktion som ger ett fel propageras felet automatiskt upp genom stacken. Ni behöver inte kasta om felet — låt det bara passera genom att inte fånga det. Fånga endast fel på den nivå där ni kan hantera eller rapportera dem på ett meningsfullt sätt.

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

Stackspårning med debug.traceback

Ett vanligt error() ger en rad med sammanhang. Använd debug.traceback(msg) som felvärde om ni vill ha en fullständig stackspårning. Detta görs vanligtvis i en xpcall-hanterare.

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

Kasta om fel

Ibland fångar ni ett fel för att lägga till sammanhang och kastar sedan om det. Använd error(err, 0) (nivå 0) när ni kastar om ett strängfel, så att ytterligare ett platsprefix inte läggs till i ett redan formaterat meddelande.

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)

Snabbkontroll

Vad betyder nivå 2 i error("msg", 2)?

Besvara frågan i den interaktiva lektionen

Sammanfattning: error()

Sammanfattning:

error(msg, level) — utlöser ett fel; nivå 2 anger att anroparen är orsaken
Använd tabeller för strukturerade fel med typ och sammanhang
assert(v, msg) — idiomatisk kontroll av förvillkor
Använd error() för buggar; returnera nil+err vid förväntade fel
Kasta om med error(err, 0) för att bevara meddelandets format

Gratis att börja

Lär dig Lua med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 40
Lektioner: 159

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Funktionen error()” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Lua Academy, inklusive ”Funktionen error()”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Lua Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Funktionen error()”?

Generera fel med error() och förstå felnivåer och felmeddelanden. Ni övar på Lua Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Lua Academy?

Du behöver inga förkunskaper. Utbildningen i Lua Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”Funktionen error()”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Lua Academy-lektionen?

Ja. Varje Lua Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Lua Academy