quebrar / sair do script

Tenho um programa que faz algumas análises de dados e tem algumas centenas de linhas.

Bem no início do programa, quero fazer algum controle de qualidade e, se não houver dados suficientes, quero que o programa seja encerrado e retorne ao console R. Caso contrário, quero que o resto do código seja executado.

Eu tentei break, browsere quite nenhum deles para a execução do resto do programa (e quitpara a execução, bem como fechei completamente o R, o que não é algo que eu quero que aconteça). Meu último recurso é criar uma if-elsedeclaração como a seguir:

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

mas isso parece uma prática de codificação ruim. Estou esquecendo de algo?

Você pode usar a stopifnot()função se quiser que o programa produza um erro:

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

Não é bonito, mas aqui está uma maneira de implementar um exit()comando em R que funcione para mim.

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

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

Apenas testado levemente, mas quando executo isso, vejo this is the last messagee, em seguida, o script é abortado sem nenhuma mensagem de erro.

Reverta sua construção if-else:

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

Edit: Parece que o OP está executando um script longo, nesse caso, basta quebrar a parte do script após o controle de qualidade com

if (n >= 500) {

.... long running code here

}

Se estiver saindo de uma função , você provavelmente só desejará return(), explícita ou implicitamente.

Por exemplo, um retorno duplo 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

Por return()estar implícito, quero dizer que a última linha é como se você tivesse feito return(xx), mas é um pouco mais eficiente deixar de fora a chamada para return().

Alguns consideram o uso de várias devoluções em um estilo ruim; em funções longas, manter o controle de onde a função sai pode se tornar difícil ou sujeito a erros. Portanto, uma alternativa é ter um único ponto de retorno, mas alterar o objeto de retorno usando a if () else ()cláusula. Essa modificação foo()seria

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

Talvez você apenas queira parar de executar um script longo em algum momento. ie. como você deseja codificar permanentemente um exit () em C ou Python.

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

Esta é uma questão antiga, mas ainda não há uma solução limpa. Isso provavelmente não está respondendo a esta pergunta específica, mas aqueles que procuram respostas sobre 'como sair de um script R normalmente' provavelmente chegarão aqui. Parece que os desenvolvedores do R se esqueceram de implementar uma função exit (). De qualquer forma, o truque que encontrei é:

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

Basicamente, você usa um sinalizador para indicar a continuação ou não de um bloco de código especificado. Em seguida, você usa a stop()função para passar uma mensagem personalizada para o manipulador de erros de uma tryCatch()função. Se o manipulador de erros receber sua mensagem para sair normalmente, ele simplesmente ignora o erro e define o sinalizador de continuação como FALSE.

Você pode usar a pskillfunção do Rpacote "ferramentas" para interromper o processo atual e retornar ao console. Concretamente, tenho a seguinte função definida em um arquivo de inicialização que forneço no início de cada script. Você também pode copiá-lo diretamente no início do seu código. Em seguida, insira halt()em qualquer ponto do código para interromper a execução do script imediatamente. Esta função funciona bem no GNU / Linux e, a julgar pela Rdocumentação, também deve funcionar no Windows (mas não verifiquei).

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

Aqui:

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

Ambos quit()e stop(message)sairão do seu script. Se você estiver fornecendo seu script a partir do prompt de comando R, quit()sairá do R também.