Lua 错误处理

Die Fehlerbehandlung während der Laufzeit des Programms ist erforderlich, insbesondere bei Dateioperationen, Datenübertragungen und Web-Services-Aufrufen können unerwartete Fehler auftreten. Wenn die Verarbeitung von Fehlermeldungen nicht beachtet wird, kann dies zu Informationenausfällen und zum Ausfall des Programms führen.

In jeder Programmiersprache ist die Fehlerbehandlung erforderlich. Fehlerarten sind:

• Syntaxfehler

• Fehler bei der Ausführung

Syntaxfehler

Ein Syntaxfehler tritt in der Regel auf, wenn die Komponenten des Programms (wie Operatoren, Ausdrücke) falsch verwendet werden. Ein einfaches Beispiel ist wie folgt:

--　Datei test.lua
a ==　2

Das Ergebnis des obigen Codes ist:

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

Wie Sie sehen können, ist hier ein Syntaxfehler aufgetreten. Ein '='-Zeichen und zwei '='-Zeichen sind unterschiedlich. Ein '=' ist ein Zuweisungsausdruck, zwei '=' sind ein Vergleichsoperator.

Ein weiteres Beispiel:

for a=　1,10
　　　print(a)
end

Bei der Ausführung des obigen Programms tritt der folgende Fehler auf:

lua: test2.lua:2: 'do' erwartet in der Nähe von 'print'

Ein Syntaxfehler ist einfacher als ein Fehler bei der Ausführung. Ein Fehler bei der Ausführung kann den genauen Fehlerort nicht feststellen, während wir Syntaxfehler schnell lösen können, wie im obigen Beispiel, indem wir einfach 'do' nach dem for-Ausdruck hinzufügen:

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

Fehler bei der Ausführung

Fehler bei der Ausführung: Das Programm kann normal ausgeführt werden, gibt aber Fehlermeldungen aus. Ein Beispiel ist, dass das Programm aufgrund eines falschen Parameters beim Ausführen eine Fehlermeldung ausgibt:

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

Wenn wir den folgenden Code kompilieren und ausführen, kann die Kompilierung erfolgreich sein, aber beim Ausführen wird der folgende Fehler auftreten:

lua: test2.lua:2: versuch, lokale 'b' (einen nil-Wert) zu berechnen
Stack Traceback:
　　　　test2.lua:2: in der Funktion 'add'
　　　　test2.lua:5: in Hauptblock
　　　　[C]: ?

In Lua kann eine Funktion aufgerufen werden, auch wenn die Liste der tatsächlichen Parameter und die Liste der formalen Parameter nicht übereinstimmt, und die zusätzlichen Parameter werden verworfen, während fehlende Parameter auf nil gesetzt werden.

Der obige Fehlerbericht ist darauf zurückzuführen, dass der Parameter b auf nil gesetzt wurde und nil an der Operation teilgenommen hat. + Operation.

angenommen add im Funktionskörper nicht "return a+b" statt "print(a,b)" wenn, dann wird das Ergebnis "10 nil" Es wird kein Fehler ausgegeben.

Fehlerbehandlung

Wir können zwei Funktionen verwenden: assert und error, um Fehler zu behandeln. Ein Beispiel ist wie folgt:

local function add(a,b)
　　　assert(type(a) == "number", "a ist keine Zahl")
　　　assert(type(b) == "number", "b ist keine Zahl")
　　　return a+b
end
add(10)

Bei der Ausführung des obigen Programms tritt der folgende Fehler auf:

lua: test.lua:3:　b　ist keine Zahl
Stack Traceback:
　　　　[C]:　in　function　'assert'
　　　　test.lua:3:　in　local　'add'
　　　　test.lua:6: in Hauptblock
　　　　[C]: in ?

Im Beispiel überprüft assert zunächst den ersten Parameter, wenn alles in Ordnung ist, macht assert nichts; andernfalls wirft assert mit dem zweiten Parameter als Fehlerinformation aus.

error-Funktion

Syntax:

error　(message　[,　level])

Funktion: Beendet die ausführende Funktion und gibt den Inhalt der Nachricht als Fehlerinformation zurück (der Fehlerfunktion wird niemals zurückgegeben)

Normalerweise hängt error einige Fehlerortinformationen an die Kopfzeile der Nachricht an.

Level-Parameter gibt an, wo der Fehler ermittelt wird:

• Level=1[Standard]：Gibt den Ort des Aufrufs von error (Datei+Zeilennummer)

• Level=2：zeigt an, welche Funktion den Fehler auftreten lässt

• Level=0: Fügt keine Fehlerortinformationen hinzu

pcall und xpcall, debug

In Lua kann der Fehler mit der Funktion pcall (protected call) verwendet werden, um den auszuführenden Code zu verpacken.

pcall akzeptiert eine Funktion und die Parameter, die an diese weitergegeben werden sollen, und führt sie aus. Das Ausführungsresultat: Fehler oder kein Fehler; Rückgabewert true oder false, errorinfo.

Die Syntax ist wie folgt

if　pcall(function_name,　….)　then
--　Keine Fehler
else
--　Einige Fehler
end

Ein einfaches Beispiel:

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

Hier beachten Sie die logische Beurteilung des Rückgabewerts:

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

pcall ruft den ersten Parameter in einem "Schutzmodus" auf, daher kann pcall jeden Fehler im Ausführen der Funktion fangen.

Normalerweise möchten Sie bei einem Fehler mehr Debugging-Informationen haben, nicht nur den Ort des Fehlers. Aber pcall zerstört einen Teil des Aufrufstapels, wenn er zurückgegeben wird.

Lua bietet die Funktion xpcall an, xpcall akzeptiert den zweiten Parameter - einen Fehlerbehandlungsfall, der vor dem Auffinden eines Fehlers aufgerufen wird, bevor Lua den Aufrufstapel (unwind) aufruft, sodass Sie in dieser Funktion die debug-Bibliothek verwenden können, um zusätzliche Informationen über den Fehler zu erhalten.

Die debug-Bibliothek bietet zwei allgemeine Fehlerbehandlungsfunctionen:

• debug.debug: Bietet einen Lua-Interaktionsmodus, um den Grund für die Fehler zu überprüfen

• debug.traceback: Baut eine erweiterte Fehlermeldung basierend auf dem Aufrufstack auf

>=xpcall(function(i) print(i) error('error..') end, function() print(debug.traceback()) end,　33)
33
Stack Traceback:
stdin:1: in Funktion <stdin:1>
[C]: in Funktion 'error'
stdin:1: in Funktion <stdin:1>
[C]: in Funktion 'xpcall'
stdin:1: in Hauptblock
[C]: in ?
false　　　　　　　　nil

Beispiel für xpcall 2:

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

Bei der Ausführung des obigen Programms tritt der folgende Fehler auf:

FEHLER:2.lua:2: versuch, auf globale 'n' (einen nil-Wert) arithmetische Operation durchzuführen
false