secuencia de comandos de ruptura / salida

Tengo un programa que hace algunos análisis de datos y tiene unos cientos de líneas.

Muy temprano en el programa, quiero hacer un control de calidad y, si no hay suficientes datos, quiero que el programa finalice y vuelva a la consola R. De lo contrario, quiero que se ejecute el resto del código.

Lo he intentado break, browsery quitninguno de ellos detener la ejecución del resto del programa (y quitdetiene la ejecución, así como dejar de fumar por completo R, que no es algo que quiero que suceda). Mi último recurso es crear una if-elsedeclaración de la siguiente manera:

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

pero eso parece una mala práctica de codificación. ¿Me estoy perdiendo de algo?

Puede usar la stopifnot()función si desea que el programa produzca un error:

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

No es bonito, pero aquí hay una forma de implementar un exit()comando en R que me funciona.

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

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

Solo probado ligeramente, pero cuando ejecuto esto, veo this is the last messagey luego el script se aborta sin ningún mensaje de error.

Invierta su construcción if-else:

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

Editar: Parece que el OP está ejecutando un script largo, en ese caso, solo se necesita envolver la parte del script después del control de calidad con

if (n >= 500) {

.... long running code here

}

Si se sale de una función , probablemente solo querráreturn() , ya sea explícita o implícitamente.

Por ejemplo, un retorno doble explícito

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

Al return()estar implícito, me refiero a que la última línea es como si lo hubiera hecho return(xx), pero es un poco más eficiente dejar la llamada areturn() .

Algunos consideran que el uso de devoluciones múltiples es de mal estilo; en funciones largas, realizar un seguimiento de dónde sale la función puede resultar difícil o propenso a errores. Por lo tanto, una alternativa es tener un único punto de retorno, pero cambiar el objeto de retorno usando la if () else ()cláusula. Tal modificación foo()sería

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

Quizás solo desee dejar de ejecutar un script largo en algún momento. es decir. como si quisiera codificar una salida () en C o Python.

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

Esta es una vieja pregunta, pero aún no existe una solución clara. Esto probablemente no responde a esta pregunta específica, pero aquellos que buscan respuestas sobre 'cómo salir con gracia de un script R' probablemente aterrizarán aquí. Parece que los desarrolladores de R se olvidaron de implementar una función exit (). De todos modos, el truco que encontré es:

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

Básicamente, usa una bandera para indicar la continuación o no de un bloque de código específico. Luego, usa la stop()función para pasar un mensaje personalizado al controlador de errores de una tryCatch()función. Si el controlador de errores recibe su mensaje para salir correctamente, simplemente ignora el error y establece el indicador de continuación en FALSE.

Puede utilizar la pskillfunción en el Rpaquete "herramientas" para interrumpir el proceso actual y volver a la consola. Concretamente, tengo la siguiente función definida en un archivo de inicio que obtengo al principio de cada script. Sin embargo, también puede copiarlo directamente al comienzo de su código. Luego inserte halt()en cualquier punto de su código para detener la ejecución del script sobre la marcha. Esta función funciona bien en GNU / Linux y, a juzgar por la Rdocumentación, también debería funcionar en Windows (pero no lo comprobé).

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

Aquí:

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

Ambos quit()y stop(message)saldrán de su guión. Si está obteniendo su script desde el símbolo del sistema de R, también quit()saldrá de R.