Lua
Gestione degli errori

Usando il pcall

pcall significa "chiamata protetta". È usato per aggiungere la gestione degli errori alle funzioni. pcall funziona come try-catch in altre lingue. Il vantaggio di pcall è che l'intera esecuzione dello script non viene interrotta se si verificano errori nelle funzioni chiamate con pcall . Se si verifica un errore in una funzione chiamata con pcall viene generato un errore e il resto del codice continua l'esecuzione.

Sintassi:

pcall( f , arg1,···)

Valori di ritorno:

Restituisce due valori

1. stato (booleano)

• Restituisce true se la funzione è stata eseguita senza errori.
• Restituisce false se si è verificato un errore all'interno della funzione.

2. valore di ritorno della funzione o messaggio di errore se si è verificato un errore all'interno del blocco funzione.

pcall può essere usato per vari casi, tuttavia uno comune è quello di catturare errori dalla funzione che è stata data alla tua funzione. Ad esempio, diciamo che abbiamo questa funzione:

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

Quando gli errori di funzione dati durante l'esecuzione 3, il messaggio di errore sarà chiaro all'utente che non proviene dalla funzione, ma dalla funzione che è stata assegnata alla nostra funzione. Inoltre, con questo in mente, è possibile inviare una nota BSoD all'utente. Tuttavia, ciò dipende dall'applicazione che implementa questa funzione, poiché un'API probabilmente non lo farà.

Esempio A - Esecuzione senza 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

Esempio B - Esecuzione con 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"

Esempio - Esecuzione di codice impeccabile

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"

Gestione degli errori in Lua

Supponendo che abbiamo la seguente funzione:

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

Miglioriamolo un po '

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

Se non vogliamo che una funzione blocchi un programma anche in caso di errore, è normale che lua esegua le seguenti operazioni:

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

Ora abbiamo una funzione che si comporta in questo modo, possiamo fare cose del genere:

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

E se vogliamo che il programma si arresti in modo anomalo se qualcosa va storto, possiamo ancora farlo:

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

Fortunatamente non abbiamo nemmeno bisogno di scrivere tutto questo ogni volta; lua ha una funzione che fa esattamente questo

result = assert(foo(20))