处理错误 Lua

La gestione degli errori durante l'esecuzione del programma è necessaria, poiché durante le operazioni di file, il trasferimento dei dati e le chiamate ai web service possono verificarsi errori imprevisti. Se non si presta attenzione alla gestione delle informazioni di errore, può causare la divulgazione delle informazioni, il mancato funzionamento del programma e altri problemi.

In qualsiasi linguaggio di programmazione, è necessario gestire gli errori. I tipi di errori includono:

• Errore di sintassi

• Running error

Errore di sintassi

Gli errori di sintassi sono spesso causati da un uso improprio dei componenti del programma (ad esempio, gli operatori, le espressioni). Ecco un esempio semplice:

-- test.lua file
a == 2

The execution result of the above code is:

lua: test.lua:2: syntax error near '=='

As you can see, there is a syntax error above, a '=' sign and two '=' signs are different. One '=' is an assignment expression, and two '=' are comparison operations.

Another example:

for a= 1,10
　　　print(a)
end

Eseguire il programma sopra menzionato genererà l'errore seguente:

lua: test2.lua:2: 'do' expected near 'print'

Syntax errors are simpler than runtime errors, runtime errors cannot locate specific errors, while syntax errors can be resolved quickly, as in the above example, we just need to add 'do' under the for statement:

for a= 1,10
do
　　　print(a)
end

Running error

Running errors are when the program can run normally but will output error messages. For example, due to incorrect parameter input, the program will report an error when executed:

function add(a,b)
　　　return a+b
end
add(10)

When we compile and run the following code, the compilation can be successful, but an error will occur during execution as follows:

lua: test2.lua:2: attempt to perform arithmetic on local 'b' (a nil value)
stack traceback:
　　　　test2.lua:2: in function 'add'
　　　　test2.lua:5: in main chunk
　　　　[C]: ??

In Lua, even if the actual parameter list and the formal parameter list do not match when calling a function, it can still be called successfully, with extra parameters being discarded and missing parameters being replaced by nil.

The above error message is due to the parameter b being replaced by nil after which nil participated in the + operation.

Suppose add Not inside "return a+b" Instead "print(a,b)" In this case, the result will be "10 nil" No error will occur.

Error handling

We can use two functions: assert and error to handle errors. Here is an example:

local function add(a,b)
　　　assert(type(a) == "number", "a is not a number")
　　　assert(type(b) == "number", "b is not a number")
　　　return a+b
end
add(10)

Eseguire il programma sopra menzionato genererà l'errore seguente:

lua: test.lua:3: b is not a number
stack traceback:
　　　　[C]: in function 'assert'
　　　　test.lua:3: in local 'add'
　　　　test.lua:6: in main chunk
　　　　[C]:                                                                       in ?

Esempio: assert prima verifica il primo parametro, se non c'è problema, assert non fa nulla; altrimenti, assert lancia un errore con il secondo parametro come messaggio di errore.

Funzione error

Formato grammaticale:

error (message [, level])

Funzione: Termina la funzione in esecuzione e restituisce il contenuto del messaggio come messaggio di errore (la funzione error non restituirà mai nulla)

Di solito, error aggiunge alcune informazioni sulla posizione dell'errore all'inizio del messaggio.

Il parametro Level indica la posizione dell'errore da ottenere:

• Level=1[predefinito]: Posizione di chiamata di error (file + numero di riga)

• Level=2: Indica quale funzione ha chiamato error

• Level=0: Non aggiungere informazioni sulla posizione dell'errore

pcall e xpcall, debug

Gestione degli errori in Lua, può utilizzare la funzione pcall (protected call) per avvolgere il codice da eseguire.

pcall accetta una funzione e i parametri da passare a quest'ultima, e l'esegue, il risultato dell'esecuzione: ci sono errori, non ci sono errori; restituisce true o false, errorinfo.

Formato grammaticale:

if pcall(function_name, ...) then
-- Nessun errore
else
-- Alcuni errori
end

Esempio semplice:

> =pcall(function(i) print(i) end, 33)
33
true
　　　
> =pcall(function(i) print(i) error('error..') end, 33)
33
false stdin:1: error..

Ecco un esempio di giudizio logico sui valori di ritorno:

> function f() return false, 2 end
> if f() then print '1' else print '0' end
0

pcall chiama il primo parametro in un modo "protettivo", quindi pcall può catturare qualsiasi errore durante l'esecuzione della funzione.

Di solito, quando si verifica un errore, si desidera ottenere più informazioni di debug, non solo la posizione dell'errore. Ma quando pcall restituisce, ha già distrutto parte del pila delle chiamate.

Lua fornisce la funzione xpcall, xpcall accetta come secondo parametro un funzione di gestione degli errori, quando si verifica un errore, Lua chiama la funzione di gestione degli errori prima di eseguire l'espansione del pila (unwind), quindi è possibile utilizzare la libreria debug in questa funzione per ottenere informazioni aggiuntive sull'errore.

La libreria debug fornisce due funzioni di gestione degli errori comuni:

• debug.debug: fornisce un prompt Lua per consentire agli utenti di verificare la causa dell'errore

• debug.traceback: costruisce un messaggio di errore esteso basato sul stack di chiamate

>=xpcall(function(i)    print(i)    error('error..')    end,    function()    print(debug.traceback())    end,    33)
33
stack traceback:
stdin:1:                                                                   in funzione <stdin:1>
[C]:                                                                       in funzione 'error'
stdin:1:                                                                   in funzione <stdin:1>
[C]:                                                                       in funzione 'xpcall'
stdin:1:                                                                   in main chunk
[C]:                                                                       in ?
false                                                                       diventa_nullo

Esempio di utilizzo xpcall 2:

function    myfunction    ()
　　　n    =    n/diventa_nullo
end
function    myerrorhandler(    err    )
　　　print(    "ERROR:",    err    )
end
status    =    xpcall(    myfunction,    myerrorhandler    )
print(    status)

Eseguire il programma sopra menzionato genererà l'errore seguente:

ERROR:             test2.lua:2: tentativo di eseguire un'operazione aritmetica su un valore globale 'n' (valore nil)
false