Skript unterbrechen / beenden

Ich habe ein Programm, das einige Datenanalysen durchführt und einige hundert Zeilen lang ist.

Sehr früh im Programm möchte ich eine Qualitätskontrolle durchführen. Wenn nicht genügend Daten vorhanden sind, soll das Programm beendet werden und zur R-Konsole zurückkehren. Ansonsten möchte ich, dass der Rest des Codes ausgeführt wird.

Ich habe versucht break, browserund quitkeiner von ihnen die Ausführung der Rest des Programms stoppen (und quitstoppt die Ausführung sowie vollständig beenden R, die nicht etwas , was ich passieren soll , ist). Mein letzter Ausweg ist die Erstellung einer if-elseErklärung wie folgt :

 if(n < 500){}
 else{*insert rest of program here*}

aber das scheint eine schlechte Codierungspraxis zu sein. Vermisse ich etwas

Sie können die stopifnot()Funktion verwenden, wenn das Programm einen Fehler erzeugen soll:

foo <- function(x) {
    stopifnot(x > 500)
    # rest of program
}

Nicht schön, aber hier ist eine Möglichkeit, einen exit()Befehl in R zu implementieren, der für mich funktioniert.

exit <- function() {
  .Internal(.invokeRestart(list(NULL, NULL), NULL))
}

print("this is the last message")
exit()
print("you should not see this")

Nur leicht getestet, aber wenn ich dies ausführe, sehe ich this is the last messageund dann bricht das Skript ohne Fehlermeldung ab.

Kehren Sie Ihre if-else-Konstruktion um:

if(n >= 500) {
  # do stuff
}
# no need for else

Vielleicht möchten Sie irgendwann einfach aufhören, ein langes Skript auszuführen. dh. Als ob Sie ein exit () in C oder Python hart codieren möchten.

print("this is the last message")
stop()
print("you should not see this")

Bearbeiten: Scheint, dass das OP ein langes Skript ausführt. In diesem Fall muss nur der Teil des Skripts nach der Qualitätskontrolle mit umbrochen werden

if (n >= 500) {

.... long running code here

}

Wenn Sie aus einer Funktion ausbrechen möchten Sie wahrscheinlich nur return()explizit oder implizit.

Zum Beispiel eine explizite doppelte Rückgabe

foo <- function(x) {
  if(x < 10) {
    return(NA)
  } else {
    xx <- seq_len(x)
    xx <- cumsum(xx)
  }
  xx ## return(xx) is implied here
}

> foo(5)
[1] 0
> foo(10)
 [1]  1  3  6 10 15 21 28 36 45 55

Mit return()impliziert meine ich, dass die letzte Zeile so ist, als ob Sie es getan hätten return(xx), aber es ist etwas effizienter, den Anruf an abzubrechenreturn() .

Einige erwägen, einen schlechten Stil für mehrere Rückgaben zu verwenden. Bei langen Funktionen kann es schwierig oder fehleranfällig werden, zu verfolgen, wo die Funktion beendet wird. Daher besteht eine Alternative darin, einen einzelnen Rückgabepunkt zu haben, das Rückgabeobjekt jedoch mithilfe der if () else ()Klausel zu ändern . Eine solche Änderung foo()wäre

foo <- function(x) {
  ## out is NA or cumsum(xx) depending on x
  out <- if(x < 10) {
    NA
  } else {
    xx <- seq_len(x)
    cumsum(xx)
  }
  out ## return(out) is implied here
}

> foo(5)
[1] NA
> foo(10)
 [1]  1  3  6 10 15 21 28 36 45 55

Dies ist eine alte Frage, aber es gibt noch keine saubere Lösung. Dies beantwortet wahrscheinlich nicht diese spezielle Frage, aber diejenigen, die nach Antworten suchen, wie man ein R-Skript ordnungsgemäß verlässt, werden wahrscheinlich hier landen. Es scheint, dass R-Entwickler vergessen haben, eine exit () -Funktion zu implementieren. Der Trick, den ich gefunden habe, ist:

continue <- TRUE

tryCatch({
     # You do something here that needs to exit gracefully without error.
     ...

     # We now say bye-bye         
     stop("exit")

}, error = function(e) {
    if (e$message != "exit") {
        # Your error message goes here. E.g.
        stop(e)
    }

    continue <<-FALSE
})

if (continue) {
     # Your code continues here
     ...
}

cat("done.\n")

Grundsätzlich verwenden Sie ein Flag, um die Fortsetzung eines bestimmten Codeblocks anzuzeigen oder nicht. Anschließend verwenden Sie die stop()Funktion, um eine benutzerdefinierte Nachricht an den Fehlerbehandler einer tryCatch()Funktion zu übergeben. Wenn der Fehlerbehandler Ihre Nachricht zum ordnungsgemäßen Beenden erhält, ignoriert er den Fehler einfach und setzt das Fortsetzungsflag auf FALSE.

Mit der pskillFunktion im RPaket "tools" können Sie den aktuellen Prozess unterbrechen und zur Konsole zurückkehren. Konkret habe ich die folgende Funktion in einer Startdatei definiert, die ich am Anfang jedes Skripts beziehe. Sie können es jedoch auch direkt am Anfang Ihres Codes kopieren. Fügen Sie dann halt()an einer beliebigen Stelle in Ihren Code ein, um die Skriptausführung im laufenden Betrieb zu stoppen. Diese Funktion funktioniert gut unter GNU / Linux und nach der RDokumentation sollte sie auch unter Windows funktionieren (aber ich habe es nicht überprüft).

# halt: interrupts the current R process; a short iddle time prevents R from
# outputting further results before the SIGINT (= Ctrl-C) signal is received 
halt <- function(hint = "Process stopped.\n") {
    writeLines(hint)
    require(tools, quietly = TRUE)
    processId <- Sys.getpid() 
    pskill(processId, SIGINT)
    iddleTime <- 1.00
    Sys.sleep(iddleTime)
}

Hier:

if(n < 500)
{
    # quit()
    # or 
    # stop("this is some message")
}
else
{
    *insert rest of program here*
}

Beides quit()und stop(message)wird Ihr Skript beenden. Wenn Sie Ihr Skript über die R-Eingabeaufforderung beziehen, quit()wird R ebenfalls beendet.