[Nim] Errorhandling

Ich habe mich jetzt mal etwas intensiver in das Thema eingelesen. Das Thema ist schon sehr vielfältig. Ich habe jetzt mal ein einfach zu handhabendes Szenario als Bsp. erstellt.

Grundsätzlich gibt es ja 2 Möglichkeiten:

a) Ich lasse das Programm/die Funktion in einen Fehler laufen und fange diesen dann ab

b) Ich prüfe vor Ausführung ob z.B. Parameter fehlerhaft sind und generiere sofort selbst einen Fehler, der dann im Errorhandling weiter bearbeitet wird.

Hier soll z.B. eine Datei eingelesen werden. Ich prüfe jetzt vorher, ob sie überhaupt existiert und generiere einen Fehler, falls nicht. Wenn Prozeduren Fehler generieren, ist die Art des Fehlers in den entsprechenden Modulen vermerkt (IOError, wImageError, ..). Fehler enden immer auf ..Error.

Meine Dateiprüfung liefert aber keinen Fehler, sondern true/false. Somit ist es erforderlich einen eigenen Fehlertyp zu erstellen, dem ich dann auch einen entsprechenden Text beim Setzen mitgebe.

Falls z.B. ein Dateihandle existiert, weil eine Datei zum Schreiben geöffnet wurde und dort ein Fehler auftrat, muss dem "except:" ein "finally:" folgen mit (in diesem Fall) close(f). Wichtig!: Der finally-Zweig wird IMMER ausgeführt (unabhängig ob Fehler oder nicht), also muss diese Aktion auch ausführbar sein und nicht selbst in einen Fehler laufen.

import os

type
  FileExistsError* = object of Exception  # User-exeption, muss auf "..Error" enden!

let datei = r".\gibt-es-nicht.txt"

try:
  if not fileExists(datei):   # wenn Datei nicht existiert wird eine exception generiert (vergleichbar mit "[au3] SetError()")
    raise newException(FileExistsError, "FILE DOESN'T EXIST")
  else:
    echo readFile(datei)
except FileExistsError:       # wenn FileExistsError auftritt (vergleichbar mit "[au3] If @error"):
  echo getCurrentExceptionMsg()

Doku: Raise & Try

P.S.

Falls ihr noch weitere Bsp. zum Errorhandling habt, bitte hier posten. Das Thema ist so komplex, da ist eine Sammlung sicher hilfreich.

Zitat von Bitnugger

So bekomme ich allerdings ein Problem angezeigt...

Hab ich eigentlich nicht als Problem verstanden, sondern als reinen Hinweis: "ererbt von einem genaueren Ausnahmetyp wie ValueError, IOError oder OSError"

Ich habe mal noch eine eigene Form des Fehlermanagements erstellt.

Man kann zwar super mit try-except innerhalb der Funktionen arbeiten, jedoch ist der Typ eines Rückgabewertes fix. Somit muss ich einen Wert der diesem Typ entspricht auch im Fehlerfall zurückgeben. Dazu wird dann ein ungültiger Wert zurückgegeben. Das ist dann aber sehr speziell auf jede einzelne Funktion und deren Datentyp zugeschnitten. Ich wollte etwas in der Art "If @error" haben.

Die typgerechte Rückgabe aus einer Funktion auch im Fehlerfall bleibt davon unberührt, aber ich habe eine allgemeingültige Fehlervariable, die sich dann auch schlüssiger lesen lässt.

Die Fehlerfunktion wird mit dem Ergebnis einer Prüfung als Parameter aufgerufen. Zusätzlich wird ein (optionaler) Text für den Fehlerfall mitgegeben. Hier ist zu beachten, dass nur eine ungültige Prüfung (false) zum Fehler führt. Das Ergebnis der Prüfung wird von der Fehlerfunktion weitergeleitet, kann aber auch ignoriert werden (Bsp #2).

# ------------------------------------------------------------------------------
# allgemeine Fehlervariable des Programms
var error = (isErr: false, msg: "")   

# myErr wird an das Resultat einer Bedingung geknüpft und leitet dieses weiter.
proc myErr(condition: bool = true, errMsg: string = ""): bool {.discardable.} =
  if condition == true:
    error = (isErr: false, msg: "")
    return true
  else:
    error = (isErr: true, msg: errMsg)
    return false
# ------------------------------------------------------------------------------

# example: 
let
  a = 5
  b = 4

#1:
if (a < b).myErr("a ist > b!"):
  echo b - a
else:
  echo error.msg

#2:
(a < b).myErr("a ist > b!")
if error.isErr: echo error.msg
else: echo b - a