web-dev-qa-db-fra.com

script de pause / sortie

J'ai un programme d'analyse de données qui compte quelques centaines de lignes.

Très tôt dans le programme, je souhaite effectuer un contrôle de la qualité et s’il n’ya pas assez de données, je souhaite que le programme se termine et revienne à la console R. Sinon, je veux que le reste du code soit exécuté.

J'ai essayé break, browser et quit et aucun d'entre eux n'arrête l'exécution du reste du programme (et quit interrompt l'exécution en tant que ainsi que de quitter complètement R, ce qui n’est pas quelque chose que je veux arriver). Mon dernier recours crée un if-else déclaration comme ci-dessous:

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

mais cela semble être une mauvaise pratique de codage. Est-ce que je manque quelque chose?

rexitbreak
69
user2588829

Vous pouvez utiliser la fonction stopifnot() si vous voulez que le programme génère une erreur:

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

Inverser votre construction if-else:

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

Pas joli, mais voici un moyen d'implémenter une commande exit() dans R qui fonctionne pour moi.

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

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

Seulement légèrement testé, mais quand je lance ceci, je vois this is the last message puis le script s'interrompt sans message d'erreur.

10
jochen

Edit: Semble que l'OP exécute un long script. Dans ce cas, il suffit d'envelopper la partie du script après le contrôle qualité avec

if (n >= 500) {

.... long running code here

}

Si vous arrêtez une fonction, vous voudrez probablement juste return(), explicitement ou implicitement.

Par exemple, un double retour explicite

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

Par return() implicite, je veux dire que la dernière ligne est comme si vous aviez fait return(xx), mais il est légèrement plus efficace de laisser l'appel à return().

Certains envisagent d'utiliser plusieurs retours de mauvais style; dans les fonctions longues, il peut être difficile de garder une trace du lieu où la fonction est sortie ou de générer des erreurs. Par conséquent, une alternative consiste à avoir un point de retour unique, mais à modifier l'objet de retour à l'aide de la clause if () else (). Une telle modification de foo() serait

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
7
Gavin Simpson

Peut-être que vous voulez juste arrêter d’exécuter un long script à un moment donné. c'est à dire. comme vous voulez coder durement un exit () en C ou en Python.

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

C'est une vieille question, mais il n'y a pas encore de solution propre. Cela ne répond probablement pas à cette question précise, mais ceux qui cherchent des réponses sur la façon de sortir gracieusement d'un script R vont probablement atterrir ici. Il semble que les développeurs R aient oublié d'implémenter une fonction exit (). Quoi qu'il en soit, le truc que j'ai trouvé est:

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

Fondamentalement, vous utilisez un indicateur pour indiquer la poursuite ou non d'un bloc de code spécifié. Vous utilisez ensuite la fonction stop() pour transmettre un message personnalisé au gestionnaire d'erreurs d'une fonction tryCatch(). Si le gestionnaire d'erreurs reçoit votre message pour qu'il se ferme normalement, il ignore simplement l'erreur et définit l'indicateur de continuation sur FALSE.

1
user2641103

Vous pouvez utiliser la fonction pskill du package R "tools" pour interrompre le processus en cours et revenir à la console. Concrètement, la fonction suivante est définie dans un fichier de démarrage que je source au début de chaque script. Vous pouvez également le copier directement au début de votre code, cependant. Ensuite, insérez halt() à tout moment dans votre code pour arrêter l'exécution du script à la volée. Cette fonction fonctionne bien sous GNU/Linux et à en juger par la documentation R, elle devrait également fonctionner sous Windows (mais je n'ai pas vérifié).

# 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)
}
1
François Tonneau

Ici:

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

quit() et stop(message) quitteront votre script. Si vous sourcez votre script à partir de l'invite de commande R, alors quit() quittera également R.

0
stackoverflowuser2010