script di interruzione / uscita

Ho un programma che esegue un'analisi dei dati ed è lungo poche centinaia di righe.

All'inizio del programma, desidero eseguire un controllo di qualità e se non ci sono dati sufficienti, desidero che il programma termini e torni alla console R. Altrimenti, voglio che il resto del codice venga eseguito.

Ho provato break, browsere quite nessuno di loro fermo l'esecuzione del resto del programma (e quitinterrompe l'esecuzione di R così come completamente smettere, che non è qualcosa che voglio che accada). La mia ultima risorsa è creare una if-elsedichiarazione come di seguito:

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

ma sembra una cattiva pratica di codifica. Mi sto perdendo qualcosa?

È possibile utilizzare la stopifnot()funzione se si desidera che il programma produca un errore:

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

Non carino, ma ecco un modo per implementare un exit()comando in R che funziona per me.

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

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

Testato solo leggermente, ma quando lo eseguo, vedo this is the last messagee quindi lo script si interrompe senza alcun messaggio di errore.

Inverti la tua costruzione if-else:

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

Modifica: sembra che l'OP stia eseguendo uno script lungo, in tal caso è sufficiente avvolgere la parte dello script dopo il controllo di qualità con

if (n >= 500) {

.... long running code here

}

Se interrompi una funzione , probabilmente vorrai solo return(), esplicitamente o implicitamente.

Ad esempio, un doppio ritorno esplicito

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

Per return()essere sottinteso, intendo che l'ultima riga è come se l'avessi fatto return(xx), ma è leggermente più efficiente lasciare la chiamata a return().

Alcuni considerano l'utilizzo di più ritorni in un cattivo stile; nelle funzioni lunghe, tenere traccia di dove esce la funzione può diventare difficile o soggetto a errori. Quindi un'alternativa è avere un unico punto di ritorno, ma cambiare l'oggetto di ritorno usando la if () else ()clausola. foo()Sarebbe una tale modifica

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

Forse vuoi solo interrompere l'esecuzione di uno script lungo ad un certo punto. cioè. come se volessi codificare un exit () in C o Python.

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

Questa è una vecchia domanda, ma non esiste ancora una soluzione pulita. Questo probabilmente non risponde a questa domanda specifica, ma coloro che cercano risposte su "come uscire con grazia da uno script R" probabilmente atterreranno qui. Sembra che gli sviluppatori R abbiano dimenticato di implementare una funzione exit (). Comunque, il trucco che ho trovato è:

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")

Fondamentalmente, usi un flag per indicare la continuazione o meno di un blocco di codice specificato. Quindi si utilizza la stop()funzione per passare un messaggio personalizzato al gestore degli errori di una tryCatch()funzione. Se il gestore degli errori riceve il tuo messaggio per uscire correttamente, ignora semplicemente l'errore e imposta il flag di continuazione su FALSE.

È possibile utilizzare la pskillfunzione nel Rpacchetto "tools" per interrompere il processo corrente e tornare alla console. In concreto, ho la seguente funzione definita in un file di avvio che provo all'inizio di ogni script. Tuttavia, puoi anche copiarlo direttamente all'inizio del codice. Quindi inserire halt()in qualsiasi punto del codice per interrompere l'esecuzione dello script al volo. Questa funzione funziona bene su GNU / Linux e, a giudicare dalla Rdocumentazione, dovrebbe funzionare anche su Windows (ma non ho controllato).

# 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)
}

Qui:

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

Entrambi quit()e stop(message)chiuderanno il tuo script. Se stai recuperando lo script dal prompt dei comandi R, quit()uscirai anche da R.