Jak mogę odczytać parametry wiersza poleceń ze skryptu R?

Kilka punktów:

1. Parametry wiersza poleceń to dostępne przez commandArgs(), więc zobacz help(commandArgs) dla przegląd.

2. Możesz używać Rscript.exe na wszystkich platformach, w tym Windows. Będzie obsługiwać commandArgs(). littler Może być przeniesiony na Windows, ale teraz żyje tylko na OS X i Linux.

3. Istnieją dwa dodatkowe pakiety CRAN -- getopt i optparse -- które zostały napisane dla wiersza poleceń parsowanie.

Edytuj w listopadzie 2015: pojawiły się nowe alternatywy i z całego serca Polecamdocopt .

Dodaj to do góry skryptu:

args<-commandArgs(TRUE)

Następnie można odnieść się do argumentów przekazywanych jako args[1], args[2] itd.

Następnie uruchom

Rscript myscript.R arg1 arg2 arg3

Jeśli Twoje args są ciągami znaków ze spacjami w nich, Zamknij w cudzysłowach.

Spróbuj library (getopt)... jeśli chcesz, żeby było milej. Na przykład:

spec <- matrix(c(
        'in'     , 'i', 1, "character", "file from fastq-stats -x (required)",
        'gc'     , 'g', 1, "character", "input gc content file (optional)",
        'out'    , 'o', 1, "character", "output filename (optional)",
        'help'   , 'h', 0, "logical",   "this help"
),ncol=5,byrow=T)

opt = getopt(spec);

if (!is.null(opt$help) || is.null(opt$in)) {
    cat(paste(getopt(spec, usage=T),"\n"));
    q();
}

You need littler (wymawiane 'little r')

Dirk będzie za jakieś 15 minut do rozwinięcia;)

Ponieważ optparse zostało wspomniane kilka razy w odpowiedziach i zapewnia kompleksowy zestaw do przetwarzania wiersza poleceń, oto krótki uproszczony przykład, jak możesz go użyć, zakładając, że plik wejściowy istnieje:

scenariusz.R:

library(optparse)

option_list <- list(
  make_option(c("-n", "--count_lines"), action="store_true", default=FALSE,
    help="Count the line numbers [default]"),
  make_option(c("-f", "--factor"), type="integer", default=3,
    help="Multiply output by this number [default %default]")
)

parser <- OptionParser(usage="%prog [options] file", option_list=option_list)

args <- parse_args(parser, positional_arguments = 1)
opt <- args$options
file <- args$args

if(opt$count_lines) {
  print(paste(length(readLines(file)) * opt$factor))
}

Podano dowolny plik blah.txt z 23 liniami.

W wierszu poleceń:

Rscript script.R -h wyjścia

Usage: script.R [options] file


Options:
        -n, --count_lines
                Count the line numbers [default]

        -f FACTOR, --factor=FACTOR
                Multiply output by this number [default 3]

        -h, --help
                Show this help message and exit

Rscript script.R -n blah.txt wyniki [1] "69"

Rscript script.R -n -f 5 blah.txt wyjścia [1] "115"

W bash możesz zbudować wiersz poleceń w następujący sposób:

$ z=10
$ echo $z
10
$ Rscript -e "args<-commandArgs(TRUE);x=args[1]:args[2];x;mean(x);sd(x)" 1 $z
 [1]  1  2  3  4  5  6  7  8  9 10
[1] 5.5
[1] 3.027650
$

Widać, że zmienna $z jest zastąpiona przez powłokę bash " 10 " i ta wartość jest pobierana przez commandArgs i przekazywana do args[2], A polecenie range x=1:10 wykonywane przez R pomyślnie, itd itd.

FYI: istnieje funkcja args (), która pobiera argumenty funkcji R, nie mylić z wektorem argumentów o nazwie args

Jeśli chcesz podać opcje z flagami, (jak -h, --help, -- number = 42, itd.) możesz użyć pakietu r optparse (zainspirowanego Pythonem): http://cran.r-project.org/web/packages/optparse/vignettes/optparse.pdf .

Przynajmniej tak rozumiem twoje pytanie, ponieważ znalazłem ten post, gdy szukałem odpowiednika Bash getopt, lub perl Getopt, lub python argparse i optparse.

Po prostu zebrałem ładną strukturę danych i łańcuch przetwarzania, aby wygenerować takie zachowanie przełączania, bez bibliotek potrzebnych. Jestem pewien, że będzie to realizowane wiele razy, i natknąłem się na ten wątek szukając przykładów-pomyślałem, że się wkręcę.

Nie potrzebowałem nawet znaczników (jedynym znacznikiem tutaj jest tryb debugowania, tworzenie zmiennej, którą sprawdzam jako warunek uruchomienia funkcji downstream if (!exists(debug.mode)) {...} else {print(variables)}). FLAG checking lapply to samo co:

if ("--debug" %in% args) debug.mode <- T
if ("-h" %in% args || "--help" %in% args) 

Gdzie args jest zmienną odczytywaną z argumentów linii poleceń (wektor znakowy, równoważny c('--debug','--help'), gdy na przykład je podasz)

Jest wielokrotnego użytku dla każdej innej flagi i unikasz powtarzania, bez bibliotek, więc bez zależności:

args <- commandArgs(TRUE)

flag.details <- list(
"debug" = list(
  def = "Print variables rather than executing function XYZ...",
  flag = "--debug",
  output = "debug.mode <- T"),
"help" = list(
  def = "Display flag definitions",
  flag = c("-h","--help"),
  output = "cat(help.prompt)") )

flag.conditions <- lapply(flag.details, function(x) {
  paste0(paste0('"',x$flag,'"'), sep = " %in% args", collapse = " || ")
})
flag.truth.table <- unlist(lapply(flag.conditions, function(x) {
  if (eval(parse(text = x))) {
    return(T)
  } else return(F)
}))

help.prompts <- lapply(names(flag.truth.table), function(x){
# joins 2-space-separatated flags with a tab-space to the flag description
  paste0(c(paste0(flag.details[x][[1]][['flag']], collapse="  "),
  flag.details[x][[1]][['def']]), collapse="\t")
} )

help.prompt <- paste(c(unlist(help.prompts),''),collapse="\n\n")

# The following lines handle the flags, running the corresponding 'output' entry in flag.details for any supplied
flag.output <- unlist(lapply(names(flag.truth.table), function(x){
  if (flag.truth.table[x]) return(flag.details[x][[1]][['output']])
}))
eval(parse(text = flag.output))

Zauważ, że w flag.details tutaj polecenia są przechowywane jako ciągi znaków, a następnie oceniane za pomocą eval(parse(text = '...')). Optparse jest oczywiście pożądany dla każdego poważnego skryptu, ale Kod o minimalnej funkcjonalności też jest dobry czasami.

Przykładowe wyjście:

$ Rscript check_mail.Rscript --help
--debug Print  variables rather than executing function XYZ...

-h  --help  Display flag definitions