Geschützte Aufrufe mit pcall()

Teil des Abschnitts Logik und Programmablauf der Lua-Journey von Coddy. Lektion 33 von 54.

Während error() dein Programm anhält, wenn etwas schiefgeht, möchtest du Fehler manchmal behandeln, ohne dass das Programm abstürzt. Mit Lua kannst du mithilfe der Funktion pcall() Code sicher ausführen, der fehlschlagen könnte.

Der Name pcall() steht für „geschützter Aufruf“. Er umhüllt einen Funktionsaufruf mit einer Schutzschicht, die alle Fehler abfängt. Anstatt dass dein Programm abstürzt, gibt pcall() Informationen darüber zurück, was passiert ist.

Hier ist die grundlegende Syntax:

local status, result = pcall(functionName, arg1, arg2)

Die Funktion pcall() gibt zwei Werte zurück. Der erste ist ein boolescher Status: true, wenn die Funktion erfolgreich war, oder false, wenn ein Fehler aufgetreten ist. Der zweite Wert hängt vom Status ab: Bei Erfolg ist es der Rückgabewert der Funktion; bei einem Fehler ist es die Fehlermeldung.

Hier ist ein praktisches Beispiel:

function divide(a, b)
    if b == 0 then
        error("Cannot divide by zero")
    end
    return a / b
end
local success, result = pcall(divide, 10, 0)
if success then
    print("Result: " .. result)
else
    print("Error caught: " .. result)
end

In diesem Beispiel löst die Division durch null einen Fehler aus, aber statt abzustürzen, fängt pcall() ihn ab. Das Programm läuft weiter und kann den Fehler elegant behandeln, indem es den Statuswert überprüft.

Beachte, dass pcall() jeden Fehler innerhalb des Aufrufs abfängt, auch unerwartete Fehler, und sie alle auf dieselbe Weise meldet. Umschließe daher nur den Aufruf, der fehlschlagen kann, und verwende bei erwarteten Fehlern vorzugsweise eine Funktion, die nil und eine Meldung zurückgibt, wie in der vorherigen Lektion.

Aufgabe

Einfach

Schreibe eine Funktion safeCalculate, die operation, a und b entgegennimmt und das Berechnungsergebnis oder eine Fehlermeldung zurückgibt.

Die Funktion soll pcall() verwenden, um die angeforderte mathematische Operation sicher auszuführen. Erstelle eine innere Funktion, die die Berechnung anhand der Operationszeichenfolge durchführt, und umschließe sie anschließend mit pcall(), um Fehler abzufangen.

Logik:

Erstelle eine innere Funktion, die den Operationstyp überprüft und die Berechnung durchführt
Gib für "add" a + b zurück
Gib für "subtract" a - b zurück
Gib für "multiply" a * b zurück
Prüfe für "divide", ob b 0 ist, und rufe error("Division by zero", 0) auf, wenn das zutrifft; gib andernfalls a / b zurück
Rufe bei jeder anderen Operation error("Invalid operation", 0) auf
Verwende pcall(), um die innere Funktion auszuführen
Gib bei Erfolg "Result: " gefolgt vom Ergebnis zurück
Gib bei einem Fehler "Error: " gefolgt von der Fehlermeldung zurück

Übergib 0 als zweites Argument an error(). Dieses Argument ist die Fehlerstufe, und 0 weist Lua an, den Dateinamen und die Zeilennummer nicht vor deine Meldung zu setzen, sodass die zurückgegebene Zeichenfolge genau "Error: Division by zero" lautet.

Parameter:

operation (Zeichenfolge): Die auszuführende Operation ("add", "subtract", "multiply" oder "divide")
a (Zahl): Der erste Operand
b (Zahl): Der zweite Operand

Rückgabewert: Eine Zeichenfolge, die entweder "Result: " gefolgt vom Berechnungsergebnis oder "Error: " gefolgt von der Fehlermeldung enthält (Zeichenfolge)

Probier es selbst

function safeCalculate(operation, a, b)
    -- Schreibe hier den Code
    -- Hinweis: Rufe error(message, 0) auf, damit Lua nicht den Dateinamen und die
    -- Zeilennummer vor deine Nachricht setzt.
end