I have installed R extension and radian to use R from VS code.
I wanted to run selected line(s) as I do in Rstudio.
Even though it appears to be set among "Keyboard Shortcuts" the shortcut cmd+enter (see pic) doesn't seem to work. Anyone can think of why?
I figured it out!
First a clarification: the issue was only affecting code in *.rmd|*.Rmd files, while normal *.R script were doing OK.
As for the *.rmd files, following the instructions here I added this in my settings.json file:
{
"files.associations": {
"*.Rmd": "rmd"
}
}
Now my shortcut cmd+enter works like a breeze ✅
PS: there may be issues also with conflicting keyboard shortcuts. In fact I deleted some that I have no interest in, but that did not solve it.
With this in .Rprofile (first line copied from ?Startup examples):
.First <- function() cat("\n Welcome to R!\n\n")
foo <- "bar"
I do not see the Welcome text. The following shows that .Rprofile executes.
ls()
[1] "foo"
Apparently .First() does not execute. Any idea why not?
I'm running in an Rgui console on win7pro with R v3.6.1 x64.
I already learned that I will not be able to do what I wanted to do in .First(), but I still want to know why it is not even executing. I might want to use it for something in the future. I haven't made any fancy configuration changes, and I launch the console from a shortcut to Rgui.exe.
Solved: Early on I had bad code in .First(). While troubleshooting I cleared the workspace with
rm(list=ls())
q('yes')
That way the assignment foo<-"bar" more clearly showed that .Rprofile was executing. What I didn't realize was that the bad .First() got saved in some hidden environment in .RData. After that, no matter what I did with .First() in .Rprofile, it always got replaced with the bad one. To solve the problem, I just needed to delete .RData.
Update: .First() does not go into a hidden environment, but the starting dot makes it hide from ls(). To exit with a completely clear workspace, the code would be:
rm( list=ls(all.names=T) )
q('yes')
That's a lot of typing. In the future, I think I'll just delete .RData.
To me this seems a lot like a bug. Anytime you change .First() in .Rprofile, you need to delete .RData from every folder where you use R or execute rm(.First) and `q('yes') in every folder. That just begs for something to be missed.
I'm trying to call a simple python script from within R using system2(). I've read some information I found vague that said if 'too much' memory is used, it won't work.
If I load a large dataset and use some information in it to use as arguments to pass into system2(), it will only work if I manually click "Restart R" in call Rstudio.
What I want:
df <- read.csv('some_large_file.csv')
###extracting some info called 'args_vec'
for(arg in args_vec){
system2('python', args)
}
This won't work as is. The for loop is simply passed over.
What I need:
df <- read.csv('some_large_file.csv')
###extracting some info called 'args_vec'
###something that 'restarts' R
for(arg in args_vec){
system2('python', args)
}
This answer doesn't quite get what I want. Namely, it doesn't work for me within Rstudio and it calls "system" (which presents the same problem as "system2" in this case). In fact, when I put the answer referenced above in my Rprofile.site file, it just immediately closed rstudio:
I tried the suggestion as a normal function (rather than using "makeActiveBinding", and it didn't quite work.
##restart R in r session -- doesn't work
makeActiveBinding("refresh", function() { system("R --save"); q("no") }, .GlobalEnv)
##nor did this:
refresh <- function() { system("R --save"); q("no") }
I tried a number of variations of these two options above, but this is getting long for what feels like a simple question. There's a lot I don't yet understand about the startup process and "makeActiveBinding" is a bit mysterious. Can anyone point me in the right direction?
In Rstudio, you can restart the R session by:
command/ctrl + shift + F10
You can also use:
.rs.restartR()
RStudio has this undocumented rs.restartR() which is supposed to do just that: restarting R.
However, it does not unload the packages that were loaded, nor does it clean the environment, so that I have some doubts about if it restarts R at all.
If you use RStudio, use the menu item Session > Restart R or the associated keyboard shortcut Ctrl+Shift+F10 (Windows and Linux) or Command+Shift+F10 (Mac OS). Additional keyboard shortcuts make it easy to restart development where you left off, i.e. to say “re-run all the code up to HERE”:
In an R script, use Ctrl+Alt+B (Windows and Linux) or Command+Option+B (Mac OS)
In R markdown, use Ctrl+Alt+P (Windows and Linux) or Command+Option+P (Mac OS)
If you run R from the shell, use Ctrl+D or q() to quit, then restart R.
Have you tried embedding the function call within the apply function, rather than a for loop?
I've had some pieces of code that ran the system out of memory in a for loop run perfectly with apply. It might help?
For those not limited to a command that want something that actually resets the system (no prior state, no loaded packages, no variables, etc.) you can select Terminate R from the Session menu.
It is a bit awkward (asks you if you are sure). If anyone knows something like clear all or really clear classes in MATLAB let me know!
In R, how to remove all of the typed commands from the command window, so that I can have a clearer working environment.
On windows using RGui, a mac inside the terminal, or on Linux: Ctrl+L will clear the screen for you. You won't be able to scroll up to view what you've done in the session previously though. You can still use the up arrow to scroll through your history though.
On a mac using the gui: Option+Command+L will do the same thing as clearing in the windows gui.
On any system: You could create a function to do something similar to clearing the screen for you:
clr <- function(){cat(rep("\n", 50))}
All this does is prints enough linebreaks to essentially push everything above what is viewable on the console. You can still scroll up to view the previous output but you'll have 50 lines of whitespace. Depending on your monitor size you might need to increase the number of line breaks to clear everything.
As others pointed out its CTRL + L otherwise you may find this helpful if you are using Windows: function to clear screen
The functions that appear in that blog post seem to be copied (without giving attribution) from this r-help post and this r-help post.
EDIT:
Added caveat about Windows and also link to original original source.
In RGui, just press Ctrl+L and you should have a clean command line window.
try this:
cls <- function(){
if (getIdentification() == 'R Console')
cat('\f') # R Console
else{
if (Sys.info()[['sysname']] == 'windows')
system('powershell clear-host') # Windows
else
system('clear') # *Unix
}
}
this function may works both on windows, and *Unix.
i don't have a computer runs *Unix system, if this code works on Mac or Linux, let me know.
Is there a way I can make an alias, within R, that will execute q() and then restart a clean R session?
And yes, I am too lazy to type q() and then the letter R :)
If you're in RStudio:
command/ctrl + shift + F10
You can also use
.rs.restartR()
Depending on how you start R try placing one of these lines into your .Rprofile file:
makeActiveBinding("refresh", function() { shell("Rgui"); q("no") }, .GlobalEnv)
makeActiveBinding("refresh", function() { system("R"); q("no") }, .GlobalEnv)
Then entering this into the R console:
refresh
will shut down the current session and start up a new one.
I found that .rs.restartR() works similar to pressing ctrl+shift+F10. but dose not unload the packages
As another alternative, Emacs ESS (>= 16.10) can reload the inferior R process via inferior-ess-r-reload-hook which is bound to C-c C-e C-r by default.
After looking for a solution to this, I solved my problem based on this solution here, using the R Package RDCOMClient.
The solution bellow just work within RStudio (Windows), once it simulates the keypresses ctrl+ shift + F10.
The RDCOMClient package must be installed with the command bellow:
install.packages("RDCOMClient", repos = "http://www.omegahat.net/R")
The code to simulate the keypresses within RStudio (Windows 10) are:
library(RDCOMClient)
wsh <- COMCreate("Wscript.Shell")
wsh$SendKeys("^+{F10}")
In the last line in the code above, the 'ctrl' key is represented by '^' and the shift key by '+'. All the explanations for this key representaions are available here.
Just after running the last line of the code above, the whole R session in RStudio will be reset, according to #steadyfish's comment. That is, it removes all the data from current session and unload all the loaded packages in the session.
Old post, but none of the answers quite work (for me, I'm using Windows, haven't tested others), so I'll add my solution. Some of my terminology might be off here, but this should get the point across:
Above answers don't quite work
Most of the answers submitted here involve using shell or system which doesn't quite work because while they open a new R console and do instruct the original console to close, the new console is a process running in the application context of the old console. That means the original console cannot close until the new console closes. Some of the users above such as hedgedandlevered reported that closing the original console forces the new console to close. When I try, the new console does open, but the old console remains open in a frozen state until the new console is closed.
The basic problem is calling shell or system does not change the application context from the original console to the new one, and therefore the original process cannot terminate until the new console closes.
Alternative that works for me
Instead use shell.exec which would normally be used to open a file in the default application based on file type. When used on a .exe, apparently, it runs the executable. The important difference, though, is that the system starts the application in it's own separate context. So here's the code that works for me:
makeActiveBinding("restart.R", function() { shell.exec(paste0(R.home(),"/bin/x64/Rgui.exe")); q("no") }, .GlobalEnv)
You'll need to edit the file path /bin/x64/Rgui.exe to match whatever you use to start R. You just put this line in your .Rprofile file, then you can call it by entering restart.R in your R code.
The downside of this over other methods is that you can't pass command line arguments like --no-save as you would with just shell, but at least this will let you close out the original R process.
Write this function in your .Rprofile
r <- function() {
assign('.Last', function() {system('R')}, envir = globalenv())
quit(save = 'no')
}
r() restarts you R session. Loaded packages will not reload. Your environment wont be saved.
Works for Linux. No idea of what may happen on other OS
In line with Martin Morgan's idea of using .Last(); this restarts R with the same set of command-line options as previously called:
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)
}
I needed the same refresh session functionality on windows and I ended up with a slightly modified version of the code:
makeActiveBinding("refresh", function() { shell(paste0("start \"\" \"", R.home(), "/bin/x64/Rgui.exe\"")); q("no") }, .GlobalEnv)
On windows you need to modify the Rprofile.site file. It is under R's etc directory. Also watch out for the last part of the path the bin/x64 can change according to your system configuration. I hope this will help others too.
I think, one realizes the best use of R by setting a current working directory in options. Then whenever your workspace /session file starts showing you up or has enough of your work in it (in between projects) you can just rename this default session file in the working directory after closing R and R/Rstudio will automatically start you in a new workspace/session file, without disturbing your current work.
Remember to quit R and rename the current session file
Of course if you do not want to save the current work you have to make sure you reset objects or operations on them were done after copying from original objects so they are as is. Trust me, knowing you can always load the old workspaces is a temptation but is more useful than not.
In short quit R, it gives you some gap while quitting means this workspace is full, rename it after completing the quit and restart R/Rstudio with a fresh workspace. You can always load select objects in the new workspace. Ideally all important work should be in Project directories but you still need a history of your jobs to go back to at times and saved sessions come in useful at some point once you are on longer projects. If you don't need any of it just rm(list=ls())
Also, I like the RDComClient idea by #Eduardo Alvin but it has been discontinued.
ALTERNATIVE OPTION
A simple alternative to get rid of the baggage at any time inside your workspace is to use save.image
save.image("Rstreamingscience.data")
quit(save='no')
load("Rstreamingscience.data") ##G:/ADA registers##
save.image("Rstreamingscience.data")
This leaves you free to come and go as you please and open as many workspaces as you need.
makeActiveBinding("refresh", function() { system(paste0(R.home(),"/bin/i386/R")); q("no") }, .GlobalEnv)
or with --save or --no-save
paste0(R.home(),"/bin/i386/R --no-save")
I think this is what you need if you've used setwd() before calling refresh (although neither this nor the original version works for me, since it restarts R then closes itself, a new window is never opened. If anyone can comment on this, please do so)
I have written the following function.
Remember! You can only use it once, then you have to reload it after the R session restarts.
clc <- function() {
rm(list = ls(envir = globalenv()),envir = globalenv()) #clear Vars from global enviroment
gc() #grabage colector
cat("\014") #clc
.rs.restartR() #clear session
}
Sometimes detaching a package also helps.