Chiudere e riavviare una sessione R pulita dall'interno di R?

C'è un modo per creare un alias, all'interno di R, che verrà eseguito q()e quindi riavviato una sessione R pulita?

E sì, sono troppo pigro per scrivere q()e poi la lettera R:)

Se sei in RStudio: comando / ctrl + maiusc + F10

Puoi anche usare

.rs.restartR()

A seconda di come si avvia R, provare a inserire una di queste righe nel .Rprofilefile:

makeActiveBinding("refresh", function() { shell("Rgui"); q("no") }, .GlobalEnv)

makeActiveBinding("refresh", function() { system("R"); q("no") }, .GlobalEnv)

Quindi inserendolo nella console R:

refresh

chiuderà la sessione corrente e ne avvierà una nuova.

Ho scoperto che .rs.restartR () funziona in modo simile alla pressione di ctrl + maiusc + F10. ma dose non scaricare i pacchetti

In alternativa, Emacs ESS (> = 16.10) può ricaricare il processo R inferiore tramite il inferior-ess-r-reload-hookquale è vincolato di C-c C-e C-rdefault.

Vecchio post, ma nessuna delle risposte funziona abbastanza (per me, sto usando Windows, non ne ho testati altri), quindi aggiungerò la mia soluzione. Parte della mia terminologia potrebbe non essere qui, ma questo dovrebbe far capire il punto:

Le risposte sopra non funzionano del tutto

La maggior parte delle risposte presentate qui implica l'utilizzo shello systemche non funziona del tutto perché mentre aprono una nuova console R e istruiscono la console originale a chiudersi, la nuova console è un processo in esecuzione nel contesto dell'applicazione della vecchia console. Ciò significa che la console originale non può chiudersi fino alla chiusura della nuova console. Alcuni degli utenti sopra, come hedgedandlevered, hanno riferito che la chiusura della console originale forza la chiusura della nuova console. Quando provo, la nuova console si apre, ma la vecchia console rimane aperta in uno stato bloccato fino a quando la nuova console non viene chiusa.

Il problema di base è chiamare shellosystem non modificare il contesto dell'applicazione dalla console originale a quella nuova e pertanto il processo originale non può terminare fino alla chiusura della nuova console.

Alternativa che funziona per me

Utilizzare invece quello shell.execnormalmente utilizzato per aprire un file nell'applicazione predefinita in base al tipo di file. Quando viene utilizzato su un .exe, a quanto pare, esegue l'eseguibile. La differenza importante, tuttavia, è che il sistema avvia l'applicazione nel proprio contesto separato. Quindi ecco il codice che funziona per me:

makeActiveBinding("restart.R", function() { shell.exec(paste0(R.home(),"/bin/x64/Rgui.exe")); q("no") }, .GlobalEnv)

Dovrai modificare il percorso del file /bin/x64/Rgui.exein modo che corrisponda a quello che usi per avviare R. Devi solo inserire questa riga nel tuo .Rprofilefile, quindi puoi chiamarla inserendorestart.R tuo codice R.

Lo svantaggio di questo rispetto ad altri metodi è che non puoi passare argomenti della riga di comando --no-savecome faresti con solo shell, ma almeno questo ti permetterà di chiudere il processo R originale.

Dopo aver cercato una soluzione a questo, ho risolto il mio problema basato su questa soluzione qui , utilizzando il pacchetto R RDCOMClient .
La soluzione seguente funziona solo all'interno di RStudio (Windows), una volta che simula la pressione dei tasti ctrl + maiusc + F10 .

Il pacchetto RDCOMClient deve essere installato con il comando seguente:

install.packages("RDCOMClient", repos = "http://www.omegahat.net/R")

Il codice per simulare la pressione dei tasti all'interno di RStudio (Windows 10) sono:

library(RDCOMClient) 
wsh <- COMCreate("Wscript.Shell") 
wsh$SendKeys("^+{F10}") 

Nell'ultima riga del codice sopra, il tasto "ctrl" è rappresentato da "^" e il tasto Maiusc da "+". Tutte le spiegazioni per queste rappresentazioni chiave sono disponibili qui .

Subito dopo aver eseguito l'ultima riga del codice sopra, l'intera sessione R in RStudio verrà ripristinata, secondo il commento di @steadyfish . Cioè, rimuove tutti i dati dalla sessione corrente e scarica tutti i pacchetti caricati nella sessione.

Scrivi questa funzione nel tuo .Rprofile

r <- function() {
  assign('.Last',  function() {system('R')}, envir = globalenv())
  quit(save = 'no')
}

r()riavvia la sessione R. I pacchetti caricati non verranno ricaricati. Il tuo ambiente non verrà salvato.

Funziona per Linux. Nessuna idea di cosa potrebbe accadere su altri sistemi operativi

Avevo bisogno della stessa funzionalità di aggiornamento della sessione su Windows e ho finito con una versione leggermente modificata del codice:

makeActiveBinding("refresh", function() { shell(paste0("start \"\" \"", R.home(), "/bin/x64/Rgui.exe\"")); q("no") }, .GlobalEnv)

Su Windows è necessario modificare il Rprofile.sitefile. È nella etcdirectory di R. Fai attenzione anche all'ultima parte del percorso che bin/x64può cambiare in base alla configurazione del tuo sistema. Spero che questo possa aiutare anche gli altri.

In linea con l'idea di Martin Morgan di utilizzare .Last(); questo riavvia R con lo stesso insieme di opzioni della riga di comando come precedentemente chiamato:

restart_r <- function(status = 0, debug = TRUE) {
  if (debug) message("restart_r(): Customizing .Last() to relaunch R ...")
  assign(".Last", function() {
    args <- commandArgs()
    system2(args[1], args = args[-1])
  }, envir = globalenv())   
  if (debug) message("restart_r(): Quitting current R session and starting a new one ...")
  quit(save = "no", status = status, runLast = TRUE)
}

Penso che si realizzi il miglior uso di R impostando una directory di lavoro corrente nelle opzioni. Quindi ogni volta che il tuo spazio di lavoro / file di sessione inizia a mostrarti o contiene abbastanza del tuo lavoro (tra i progetti) puoi semplicemente rinominare questo file di sessione predefinito nella directory di lavoro dopo aver chiuso R e R / Rstudio ti avvierà automaticamente in un nuovo spazio di lavoro / file di sessione, senza disturbare il lavoro corrente.

Ricordarsi di chiudere R e rinominare il file della sessione corrente

Ovviamente se non vuoi salvare il lavoro corrente devi assicurarti di resettare gli oggetti o le operazioni su di essi sono state fatte dopo aver copiato dagli oggetti originali in modo che siano così come sono. Credimi, sapere che puoi sempre caricare i vecchi spazi di lavoro è una tentazione ma è più utile che no.

In breve, esci da R, ti dà un po 'di spazio mentre esci significa che questo spazio di lavoro è pieno, rinominalo dopo aver completato l'uscita e riavvia R / Rstudio con un nuovo spazio di lavoro. Puoi sempre caricare oggetti selezionati nel nuovo spazio di lavoro. Idealmente tutto il lavoro importante dovrebbe essere nelle directory del progetto, ma a volte è comunque necessaria una cronologia dei lavori a cui tornare e le sessioni salvate diventano utili a un certo punto una volta che si è impegnati in progetti più lunghi. Se non ne hai bisogno, bastarm(list=ls())

Inoltre, mi piace il file RDComClient idea di @Eduardo Alvin ma è stata interrotta.

OPZIONE ALTERNATIVA

Una semplice alternativa per sbarazzarsi del bagaglio in qualsiasi momento all'interno del proprio spazio di lavoro è usare save.image

save.image("Rstreamingscience.data")
quit(save='no')
load("Rstreamingscience.data") ##G:/ADA registers##
save.image("Rstreamingscience.data")

Questo ti lascia libero di entrare e uscire a tuo piacimento e di aprire tutti gli spazi di lavoro di cui hai bisogno.

makeActiveBinding("refresh", function() { system(paste0(R.home(),"/bin/i386/R")); q("no") }, .GlobalEnv)

o con --save o --no-save

paste0(R.home(),"/bin/i386/R --no-save")

Penso che questo sia ciò di cui hai bisogno se hai usato setwd () prima di chiamare refresh (sebbene né questa né la versione originale funzionino per me, poiché riavvia R e poi si chiude, non viene mai aperta una nuova finestra. Se qualcuno può commentare su questo, per favore fallo)

Ho scritto la seguente funzione. Ricorda! Puoi usarlo solo una volta, quindi devi ricaricarlo dopo il riavvio della sessione R.

clc <- function() {
  rm(list = ls(envir = globalenv()),envir = globalenv()) #clear Vars from global enviroment
  gc()  #grabage colector
  cat("\014") #clc
  .rs.restartR() #clear session
}

A volte è utile anche staccare un pacchetto.