Как я могу прочитать параметры командной строки из сценария R?

Несколько точек:

• Параметры командной строки: доступный через commandArgs(), поэтому см. help(commandArgs) для обзор.

• Вы можете использовать Rscript.exe на всех платформах, включая Windows. Он будет поддерживать commandArgs(). littler можно портировать в Windows, но он живет прямо сейчас только на OS X и Linux.

• В CRAN есть два дополнительных пакета - getopt и optparse - оба они были написаны для разбора командной строки.

Изменить в ноябре 2015: появились новые альтернативы, и я всем сердцем рекомендую doctopt.

Добавьте это в начало script:

args<-commandArgs(TRUE)

Затем вы можете обратиться к аргументам, переданным как args[1], args[2] и т.д.

Затем запустите

Rscript myscript.R arg1 arg2 arg3

Если ваши аргументы являются строками с пробелами в них, заключите их в двойные кавычки.

Попробуйте библиотеку (getopt)... если вы хотите, чтобы все было лучше. Например:

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

вам нужно littler (произносится как "little r" )

Дирк будет примерно через 15 минут, чтобы разработать;)

Так как optparse упоминается несколько раз в ответах, и он предоставляет исчерпывающий набор для обработки командной строки, здесь приведен короткий упрощенный пример того, как вы можете его использовать, предполагая наличие входного файла:

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

Для произвольного файла blah.txt с 23 строками.

В командной строке:

Rscript script.R -h выходы

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 выходы [1] "69"

Rscript script.R -n -f 5 blah.txt выходы [1] "115"

В bash вы можете построить командную строку следующим образом:

$ 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
$

Вы можете видеть, что переменная $z заменяется на bash shell с "10", и это значение подбирается commandArgs и подается в args[2], а команда диапазона x=1:10 выполняется R успешно и т.д. и т.д.

FYI: существует функция args(), которая извлекает аргументы из R-функций, а не путается с вектором аргументов args

Я просто собрал хорошую структуру данных и цепочку обработки для генерации этого поведения переключения, не требуя библиотек. Я уверен, что это будет реализовано много раз, и наткнулся на эту тему, ища примеры - подумал, что я запишу.

Мне даже не нужны флаги (единственный флаг здесь - это режим отладки, создающий переменную, которую я проверяю как условие запуска нисходящей функции if (!exists(debug.mode)) {...} else {print(variables)}). Операторы флага, проверяющие lapply ниже, создают такие же как:

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

где args - это переменная, считываемая из аргументов командной строки (символьный вектор, эквивалентный c('--debug','--help'), когда вы поставляете их, например)

Он многократно используется для любого другого флага, и вы избегаете всего повторения, и нет библиотек, поэтому никаких зависимостей:

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

Обратите внимание, что в flag.details здесь команды хранятся в виде строк, а затем вычисляются с помощью eval(parse(text = '...')). Optparse, очевидно, желательно для любого серьезного script, но код минимальной функциональности тоже очень хорош.

Пример вывода:

  $ Rscript check_mail.Rscript --help
--debug Печать переменных, а не выполнение функции XYZ...

-h --help Определение флагов отображения

Если вам нужно указать опции с флагами (например, -h, --help, --number = 42 и т.д.), вы можете использовать оп пакетный пакет R (вдохновленный Python): http://cran.r-project.org/web/packages/optparse/vignettes/optparse.pdf.

По крайней мере, так, как я понимаю ваш вопрос, потому что я нашел этот пост при поиске эквивалента bash getopt, или perl Getopt, или python argparse и optparse.