Saia e reinicie uma sessão R limpa de dentro de R?

Existe uma maneira de fazer um alias, dentro de R, que irá executar q()e reiniciar uma sessão R limpa?

E sim, estou com preguiça de digitar q()e depois a letra R:)

Se você estiver no RStudio: command / ctrl + shift + F10

Você também pode usar

.rs.restartR()

Dependendo de como você inicia o R, tente colocar uma destas linhas em seu .Rprofilearquivo:

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

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

Em seguida, insira isso no console R:

refresh

encerrará a sessão atual e iniciará uma nova.

Descobri que .rs.restartR () funciona de maneira semelhante a pressionar ctrl + shift + F10. mas não descarregue os pacotes

Como outra alternativa, o Emacs ESS (> = 16.10) pode recarregar o processo R inferior por meio do inferior-ess-r-reload-hookqual é vinculado C-c C-e C-rpor padrão.

Postagem antiga, mas nenhuma das respostas funciona (para mim, estou usando Windows, não testei outros), então adicionarei minha solução. Algumas das minhas terminologias podem estar erradas aqui, mas isso deve esclarecer o ponto:

As respostas acima não funcionam bem

A maioria das respostas enviadas aqui envolve o uso de shellou o systemque não funciona muito bem porque, embora eles abram um novo console R e instruam o console original a fechar, o novo console é um processo em execução no contexto do aplicativo do console antigo. Isso significa que o console original não pode ser fechado até que o novo console seja fechado. Alguns dos usuários acima, como hedgedandlevered, relataram que o fechamento do console original força o fechamento do novo console. Quando tento, o novo console abre, mas o antigo permanece aberto em um estado congelado até que o novo console seja fechado.

O problema básico é chamar shellou systemnão alterar o contexto do aplicativo do console original para o novo e, portanto, o processo original não pode terminar até que o novo console seja fechado.

Alternativa que funciona para mim

Em vez disso, use o shell.execque normalmente seria usado para abrir um arquivo no aplicativo padrão com base no tipo de arquivo. Quando usado em um .exe, aparentemente, ele executa o executável. A diferença importante, porém, é que o sistema inicia o aplicativo em seu próprio contexto separado. Então, aqui está o código que funciona para mim:

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

Você precisará editar o caminho do arquivo /bin/x64/Rgui.exepara corresponder ao que usar para iniciar R. Basta colocar esta linha em seu .Rprofilearquivo e, em seguida, chamá-la inserindo restart.Rseu código R.

A desvantagem disso em relação a outros métodos é que você não pode passar argumentos de linha de comando --no-savecomo faria com apenas shell, mas pelo menos isso permitirá que você feche o processo R original.

Depois de procurar uma solução para isso, resolvi meu problema com base nesta solução aqui , usando o Pacote R RDCOMClient .
A solução abaixo funciona apenas dentro do RStudio (Windows), uma vez que simula os pressionamentos de teclas ctrl + shift + F10 .

O pacote RDCOMClient deve ser instalado com o comando abaixo:

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

O código para simular os pressionamentos de tecla no RStudio (Windows 10) são:

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

Na última linha do código acima, a tecla 'ctrl' é representada por '^' e a tecla shift por '+'. Todas as explicações para essas representações chave estão disponíveis aqui .

Logo após executar a última linha do código acima, toda a sessão R no RStudio será reiniciada, de acordo com o comentário de @steadyfish . Ou seja, ele remove todos os dados da sessão atual e descarrega todos os pacotes carregados na sessão.

Escreva esta função em seu .Rprofile

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

r()reinicia sua sessão R. Os pacotes carregados não recarregam. Seu ambiente não será salvo.

Funciona para Linux. Não faço ideia do que pode acontecer em outro sistema operacional

Eu precisava da mesma funcionalidade de atualização da sessão no Windows e acabei com uma versão ligeiramente modificada do código:

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

No Windows, você precisa modificar o Rprofile.sitearquivo. Ele está no etcdiretório de R. Observe também a última parte do caminho que bin/x64pode ser alterado de acordo com a configuração do sistema. Espero que isso ajude outras pessoas também.

Em linha com a ideia de uso de Martin Morgan .Last(); isso reinicia o R com o mesmo conjunto de opções de linha de comando anteriormente chamado:

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

Acho que se percebe o melhor uso de R definindo um diretório de trabalho atual em opções. Então, sempre que o seu espaço de trabalho / arquivo de sessão começar a aparecer ou tiver trabalho suficiente nele (entre projetos), você pode simplesmente renomear este arquivo de sessão padrão no diretório de trabalho após fechar R e R / Rstudio irá automaticamente iniciar você em um novo arquivo de espaço de trabalho / sessão, sem atrapalhar seu trabalho atual.

Lembre-se de sair do R e renomear o arquivo da sessão atual

Obviamente, se você não quiser salvar o trabalho atual, certifique-se de redefinir os objetos ou as operações sobre eles foram feitas após a cópia dos objetos originais para que fiquem como estão. Acredite em mim, saber que você sempre pode carregar os espaços de trabalho antigos é uma tentação, mas é mais útil do que não.

Resumindo, saia do R, isso lhe dá alguma lacuna, enquanto o encerramento significa que este espaço de trabalho está cheio, renomeie-o após concluir o encerramento e reinicie o R / Rstudio com um novo espaço de trabalho. Você sempre pode carregar objetos selecionados no novo espaço de trabalho. Idealmente, todos os trabalhos importantes devem estar nos diretórios do projeto, mas você ainda precisa de um histórico de seus trabalhos para voltar às vezes e as sessões salvas podem ser úteis em algum ponto quando você estiver em projetos mais longos. Se você não precisa de nada disso, apenasrm(list=ls())

Além disso, gosto da RDComClientideia de @Eduardo Alvin mas foi descontinuada.

OPÇÃO ALTERNATIVA

Uma alternativa simples para se livrar da bagagem a qualquer momento dentro de sua área de trabalho é usar save.image

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

Isso o deixa livre para entrar e sair quando quiser e abrir quantos espaços de trabalho você precisar.

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

ou com --save ou --no-save

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

Acho que é disso que você precisa se tiver usado setwd () antes de chamar o refresh (embora nem isso nem a versão original funcionem para mim, já que ele reinicia o R e se fecha, uma nova janela nunca é aberta. Se alguém puder comentar sobre isso, por favor, faça isso)

Eu escrevi a seguinte função. Lembrar! Você só pode usá-lo uma vez, então você deve recarregá-lo depois que a sessão R for reiniciada.

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

Às vezes, retirar um pacote também ajuda.