Ausnahmebehandlung und Stapelabwicklung in R

Question

Um eine kohärente Schnittstelle zur Ausnahmebehandlung für meine Kollegen und meine R-Skripte einzurichten, möchte ich die folgende tryCatch-Struktur verwenden.

1. Ein äußerer tryCatch wird um ein bestimmtes R-Skript gewickelt.Es wird verwendet, um schwerwiegende Fehler abzufangen und zu behandeln, die einen Abbruch des Skripts erfordern.
2. Benutzerspezifische tryCatch-Befehle innerhalb der Skripte des Benutzers.Diese sollten aufgefangen und ggf. gehandhabt werden
   • 2a.nicht schwerwiegende Fehler, bei denen kein Skriptabbruch erforderlich ist
   • 2b.Schwerwiegende Fehler, die einen Abbruch des Skripts erfordern.Der Fehler wird vom äußeren tryCatch behandelt [siehe 1.]
   • 2c.fatal-errors mit zusätzlichen Fehlerinformationen.Fehler, der von äußerem tryCatch behandelt wird.

Der folgende Code zeigt, wie ich diese Funktionen implementieren würde.Da ich jedoch kein R-Experte bin, möchte ich fragen, ob dies ein guter Ansatz ist.Speziell:

Q1.Ist es in Ordnung, im inneren tryCatch keinen Fehlerhandler anzugeben und darauf zu warten, dass der äußere tryCatch diesen Fehler behandelt (siehe 2b.oben und Code unten)?

Q2.Gibt den gleichen Fehler erneut aus (siehe 2c.oben/unten) innerhalb eines Handlers richtig/als guter Codierungsstil angesehen?

Danke schön!

#outer tryCatch, see 1.
tryCatch({
  #user code block
  #2a. user specific tryCatch, object "vec" not defined
  tryCatch(print(vec),error=function(e) {print("Non-fatal error. Script execution continued.");print(e);})

  #2b. user specific tryCatch
  tryCatch(vec*2)

  #2c. user specific tryCatch
  tryCatch(vec*parameter1, error=function(e) {print("Additional fatal error information. Script execution aborted.");stop(e);})
  #end of user code block
},
     #outer tryCatch error handler in order to handle fatal errors
     error=function(e) {print("Fatal error");print(e);} 
    )

Answer 1

Es ist vollkommen in Ordnung, nur einige Fehler abzufangen und andere dem äußeren Handler oder überhaupt keinem Handler zu überlassen.Das Fehlersystem ist um einiges flexibler als normalerweise verwendet, sodass Sie zum erneuten Auslösen eines Fehlers möglicherweise über die Erstellung eines eigenen Fehlertyps nachdenken sollten

ourError <-
    function(original, message, class="ourError")
{
    msg <- paste(message, conditionMessage(original), sep="\n  ")
    structure(list(message = msg, call = conditionCall(original)),
              class = c(class, class(original)))
}

und das werfen und/oder handhaben

tryCatch(vec*parameter1, error=function(e) {
    err <- ourError(e, "addition fatal info; script aborted")
    stop(err)
})

Ein Vorteil davon besteht darin, dass im Handler der obersten Ebene mithilfe der von zurückgegebenen Klasse zusätzliche Verhaltensweisen angegeben werden können ourError()

tryCatch({
    tryCatch(stop("oops"), error=function(e) {
        err <- ourError(e, "addition fatal info; script aborted",
                      c("fatal", "ourError"))
        stop(err)
    })
}, ourError=function(err) {
    message("We caught but didn't handle this:\n", err)
}, error =function(err) {
    message("This one got away: ", err)
})