Lua
Foutafhandeling

PCall gebruiken

pcall staat voor "protected call". Het wordt gebruikt om foutafhandeling aan functies toe te voegen. pcall werkt hetzelfde als try-catch in andere talen. Het voordeel van pcall is dat de hele uitvoering van het script niet wordt onderbroken als er fouten optreden in functies die met pcall . Als er een fout optreedt in een functie met pcall een fout gegenereerd en wordt de rest van de code uitgevoerd.

Syntaxis:

pcall( f , arg1,···)

Retourwaarden:

Retourneert twee waarden

1. status (boolean)

• Retourneert true als de functie zonder fouten is uitgevoerd.
• Retourneert false als er een fout is opgetreden in de functie.

2. Retourneer de waarde van de functie of het foutbericht als er een fout is opgetreden in het functieblok.

pcall kan voor verschillende gevallen worden gebruikt, maar het is gebruikelijk om fouten op te vangen uit de functie die aan uw functie is gegeven. Laten we bijvoorbeeld zeggen dat we deze functie hebben:

local function executeFunction(funcArg, times) then
    for i = 1, times do
        local ran, errorMsg = pcall( funcArg )
        if not ran then
            error("Function errored on run " .. tostring(i) .. "\n" .. errorMsg)
        end
    end
end

Wanneer de gegeven functiefouten bij run 3 mislukken, zal het foutbericht voor de gebruiker duidelijk zijn dat het niet van uw functie komt, maar van de functie die aan onze functie werd gegeven. Met dit in gedachten kan ook een fancy BSoD worden gemaakt om de gebruiker te informeren. Dat is echter aan de applicatie die deze functie implementeert, aangezien een API dat waarschijnlijk niet zal doen.

Voorbeeld A - Uitvoering zonder pcall

function square(a)
  return a * "a"    --This will stop the execution of the code and throws an error, because of the attempt to perform arithmetic on a string value
end

square(10);

print ("Hello World")    -- This is not being executed because the script was interrupted due to the error

Voorbeeld B - Uitvoering met pcall

function square(a)
  return a * "a"
end

local status, retval = pcall(square,10);

print ("Status: ", status)        -- will print "false" because an error was thrown.
print ("Return Value: ", retval)  -- will print "input:2: attempt to perform arithmetic on a string value"
print ("Hello World")    -- Prints "Hello World"

Voorbeeld - uitvoering van foutloze code

function square(a)
  return a * a
end

local status, retval = pcall(square,10);

print ("Status: ", status)        -- will print "true" because no errors were thrown 
print ("Return Value: ", retval)  -- will print "100"
print ("Hello World")    -- Prints "Hello World"

Fouten afhandelen in Lua

Ervan uitgaande dat we de volgende functie hebben:

function foo(tab)
  return tab.a
end -- Script execution errors out w/ a stacktrace when tab is not a table

Laten we het een beetje verbeteren

function foo(tab)
  if type(tab) ~= "table" then
    error("Argument 1 is not a table!", 2)
  end
  return tab.a
end -- This gives us more information, but script will still error out

Als we niet willen dat een functie een programma crasht, zelfs in het geval van een fout, is het standaard in Lua om het volgende te doen:

function foo(tab)
    if type(tab) ~= "table" then return nil, "Argument 1 is not a table!" end
    return tab.a
end -- This never crashes the program, but simply returns nil and an error message

Nu hebben we een functie die zich zo gedraagt, we kunnen dit soort dingen doen:

if foo(20) then print(foo(20)) end -- prints nothing
result, error = foo(20)
if result then print(result) else log(error) end

En als we willen dat het programma crasht als er iets misgaat, kunnen we dit nog steeds doen:

result, error = foo(20)
if not result then error(error) end

Gelukkig hoeven we dat niet eens elke keer te schrijven; lua heeft een functie die precies dit doet

result = assert(foo(20))