from - pasar parametros por linea de comandos java

Pasar los argumentos de la línea de comando a R CMD LOTE

Question

He estado usando R CMD BATCH my_script.R desde un terminal para ejecutar un guión R Ahora estoy en el punto en el que me gustaría pasarle una discusión al comando, pero tengo algunos problemas para hacerlo funcionar. Si hago R CMD BATCH my_script.R blabla entonces blabla convierte en el archivo de salida, en lugar de ser interpretado como un argumento disponible para el script R que se está ejecutando.

He intentado con Rscript my_script.R blabla que parece transmitir correctamente blabla como argumento, pero luego no obtengo el archivo de salida my_script.Rout que obtengo con R CMD BATCH (quiero el archivo .Rout ). Si bien podría redirigir la salida de una llamada a Rscript a un nombre de archivo de mi elección, no obtendría los comandos de entrada R incluidos en el archivo como lo hace R CMD BATCH en el archivo .Rout .

Entonces, idealmente, estoy buscando una manera de pasar argumentos a un script R que se ejecuta mediante el método R CMD BATCH , aunque estaría contento con un enfoque que use Rscript si hay una manera de hacer que produzca un archivo .Rout comparable.

Answer 1

Agrego una respuesta porque creo que una solución de una línea siempre es buena. Encima de su archivo myRscript.R , agregue la siguiente línea:

eval(parse(text=paste(commandArgs(trailingOnly = TRUE), collapse=";")))

Luego envíe su script con algo como:

R CMD BATCH [options] ''--args arguments you want to supply'' myRscript.R &

Por ejemplo:

R CMD BATCH --vanilla ''--args N=1 l=list(a=2, b="test") name="aname"'' myscript.R &

Entonces:

> ls()
[1] "N" "l" "name"

Answer 2

Aquí hay otra forma de procesar argumentos de línea de comando, usando R CMD BATCH . Mi enfoque, que se basa en una respuesta anterior aquí , le permite especificar argumentos en la línea de comandos y, en su secuencia de comandos R, dar algunos o todos ellos valores predeterminados.

Aquí hay un archivo R, que llamo test.R :

defaults <- list(a=1, b=c(1,1,1)) ## default values of any arguments we might pass
## parse each command arg, loading it into global environment
for (arg in commandArgs(TRUE))
eval(parse(text=arg))
## if any variable named in defaults doesn''t exist, then create it
## with value from defaults
for (nm in names(defaults))
assign(nm, mget(nm, ifnotfound=list(defaults[[nm]]))[[1]])
print(a)
print(b)

En la línea de comando, si escribo

R CMD BATCH --no-save --no-restore ''--args a=2 b=c(2,5,6)'' test.R

luego dentro de R tendremos a = 2 b = c(2,5,6) . Pero podría, digamos, omitir b , y agregar otro argumento c :

R CMD BATCH --no-save --no-restore ''--args a=2 c="hello"'' test.R

Entonces en R tendremos a = 2 , b = c(1,1,1) (el valor predeterminado) y c = "hello" .

Finalmente, para mayor comodidad, podemos ajustar el código R en una función, siempre que tengamos cuidado con el medio ambiente:

## defaults should be either NULL or a named list
parseCommandArgs <- function(defaults=NULL, envir=globalenv()) {
for (arg in commandArgs(TRUE))
eval(parse(text=arg), envir=envir)
for (nm in names(defaults))
assign(nm, mget(nm, ifnotfound=list(defaults[[nm]]), envir=envir)[[1]], pos=envir)
}
## example usage:
parseCommandArgs(list(a=1, b=c(1,1,1)))

Answer 3

Después de probar las opciones descritas aquí, encontré esta publicación de Forester en r-bloggers. Creo que es una opción limpia a considerar.

Puse su código aquí:

Desde línea de comando

$ R CMD BATCH --no-save --no-restore ''--args a=1 b=c(2,5,6)'' test.R test.out &

Test.R

##First read in the arguments listed at the command line
args=(commandArgs(TRUE))
##args is now a list of character vectors
## First check to see if arguments are passed.
## Then cycle through each element of the list and evaluate the expressions.
if(length(args)==0){
print("No arguments supplied.")
##supply default values
a = 1
b = c(1,1,1)
}else{
for(i in 1:length(args)){
eval(parse(text=args[[i]]))
}
}
print(a*2)
print(b*3)

En test.out

> print(a*2)
[1] 2
> print(b*3)
[1] 6 15 18

Gracias a Forester !

Answer 4

En su script R, llamado test.R :

args <- commandArgs(trailingOnly = F)
myargument <- args[length(args)]
myargument <- sub("-","",myargument)
print(myargument)
q(save="no")

Desde la línea de comando ejecuta:

R CMD BATCH -4 test.R

Su archivo de salida, test.Rout, mostrará que el argumento 4 se ha pasado con éxito a R:

cat test.Rout
> args <- commandArgs(trailingOnly = F)
> myargument <- args[length(args)]
> myargument <- sub("-","",myargument)
> print(myargument)
[1] "4"
> q(save="no")
> proc.time()
user system elapsed
0.222 0.022 0.236

Answer 5

Mi impresión es que R CMD BATCH es un poco una reliquia. En cualquier caso, el ejecutable de Rscript más reciente (disponible en todas las plataformas), junto con commandArgs() hace que el procesamiento de los argumentos de línea de comando sea bastante fácil.

Como ejemplo, aquí hay un pequeño script, llámalo "myScript.R" :

## myScript.R
args <- commandArgs(trailingOnly = TRUE)
rnorm(n=as.numeric(args[1]), mean=as.numeric(args[2]))

Y aquí está lo que parece invocarlo desde la línea de comando

> Rscript myScript.R 5 100
[1] 98.46435 100.04626 99.44937 98.52910 100.78853

Editar:

No es que lo recomiende, pero ... usando una combinación de source() y sink() , podría hacer que Rscript produzca un archivo .Rout como el producido por R CMD BATCH . Una forma sería crear un pequeño guión R, llámalo RscriptEcho.R , al que llamas directamente con Rscript. Puede verse así:

## RscriptEcho.R
args <- commandArgs(TRUE)
srcFile <- args[1]
outFile <- paste0(make.names(date()), ".Rout")
args <- args[-1]
sink(outFile, split = TRUE)
source(srcFile, echo = TRUE)

Para ejecutar tu script real, entonces harías:

Rscript RscriptEcho.R myScript.R 5 100
[1] 98.46435 100.04626 99.44937 98.52910 100.78853

que ejecutará myScript.R con los argumentos suministrados y hundirá entrada, salida y mensajes intercalados en un .Rout nombre .Rout .

Edit2:
Puede ejecutar Rscript en detalle y colocar la salida detallada en un archivo.

Rscript --verbose myScript.R 5 100 > myScript.Rout

Answer 6

Necesita poner argumentos antes de my_script.R y usar - en los argumentos, por ej.

R CMD BATCH -blabla my_script.R

commandArgs() recibirá -blabla como una cadena de caracteres en este caso. Ver la ayuda para más detalles:

$ R CMD BATCH --help
Usage: R CMD BATCH [options] infile [outfile]
Run R non-interactively with input from infile and place output (stdout
and stderr) to another file. If not given, the name of the output file
is the one of the input file, with a possible ''.R'' extension stripped,
and ''.Rout'' appended.
Options:
-h, --help print short help message and exit
-v, --version print version info and exit
--no-timing do not report the timings
-- end processing of options
Further arguments starting with a ''-'' are considered as options as long
as ''--'' was not encountered, and are passed on to the R process, which
by default is started with ''--restore --save --no-readline''.
See also help(''BATCH'') inside R.