确定执行脚本的路径

您可以将 r 脚本包装在 bash 脚本中，并将脚本的路径作为 bash 变量检索，如下所示：

#!/bin/bash
     # [environment variables can be set here]
     path_to_script=$(dirname $0)

     R --slave<<EOF
        source("$path_to_script/other.R")

     EOF

可以使用该函数获取 Rscript 传递给实际 R 解释器的所有选项，并在其中搜索 .如果脚本是从该路径启动的，或者是使用完整路径启动的，则以下内容将以 .否则，它必须是相对于 和 连接这两个路径以获取完整路径。commandArgs--file=script.name'/'cwd

编辑：听起来您只需要上述内容并剥离路径的最终组件。我已经删除了不需要的示例并清理了主脚本并发布了我的 .只需将此脚本和脚本保存到同一目录中，然后运行主脚本即可。script.namecwd()other.Rother.Rchmod +x

主要。其中，中：

#!/usr/bin/env Rscript
initial.options <- commandArgs(trailingOnly = FALSE)
file.arg.name <- "--file="
script.name <- sub(file.arg.name, "", initial.options[grep(file.arg.name, initial.options)])
script.basename <- dirname(script.name)
other.name <- file.path(script.basename, "other.R")
print(paste("Sourcing",other.name,"from",script.name))
source(other.name)

其他。其中，中：

print("hello")

输出：

burner@firefighter:~$ main.R
[1] "Sourcing /home/burner/bin/other.R from /home/burner/bin/main.R"
[1] "hello"
burner@firefighter:~$ bin/main.R
[1] "Sourcing bin/other.R from bin/main.R"
[1] "hello"
burner@firefighter:~$ cd bin
burner@firefighter:~/bin$ main.R
[1] "Sourcing ./other.R from ./main.R"
[1] "hello"

这就是我相信 dehmann 正在寻找的。

frame_files <- lapply(sys.frames(), function(x) x$ofile)
frame_files <- Filter(Negate(is.null), frame_files)
PATH <- dirname(frame_files[[length(frame_files)]])

不过不要问我它是如何工作的，因为我忘记了：/

Supressingfire答案的精简版：

source_local <- function(fname){
    argv <- commandArgs(trailingOnly = FALSE)
    base_dir <- dirname(substring(argv[grep("--file=", argv)], 8))
    source(paste(base_dir, fname, sep="/"))
}

这对我有用。只需将其从命令行参数中取出，剥离不需要的文本，执行 dirname，最后从中获取完整路径：

args <- commandArgs(trailingOnly = F)  
scriptPath <- normalizePath(dirname(sub("^--file=", "", args[grep("^--file=", args)])))

当从 R 控制台“源”时，我无法让 Suppressingfire 的解决方案工作。
使用 Rscript 时，我无法让 hadley 的解决方案正常工作。

两全其美？

thisFile <- function() {
        cmdArgs <- commandArgs(trailingOnly = FALSE)
        needle <- "--file="
        match <- grep(needle, cmdArgs)
        if (length(match) > 0) {
                # Rscript
                return(normalizePath(sub(needle, "", cmdArgs[match])))
        } else {
                # 'source'd via R console
                return(normalizePath(sys.frames()[[1]]$ofile))
        }
}

这里有一个简单的问题解决方案。此命令：

script.dir <- dirname(sys.frame(1)$ofile)

返回当前脚本文件的路径。它在保存脚本后起作用。

我已经将这个问题的答案总结并扩展到 rprojroot 中的一个新函数中。也适用于针织。thisfile()knitr

请参阅 R.utils 包，其中findSourceTraceback()

查找所有调用帧中由 source（） 生成的所有 'srcfile' 对象。 这样就可以找出当前由 source（） 编写脚本的文件。

#!/usr/bin/env Rscript
print("Hello")

# sad workaround but works :(
programDir <- dirname(sys.frame(1)$ofile)
source(paste(programDir,"other.R",sep='/'))
source(paste(programDir,"other-than-other.R",sep='/'))

我喜欢这种方法：

this.file <- sys.frame(tail(grep('source',sys.calls()),n=1))$ofile
this.dir <- dirname(this.file)

我在上面的实现中遇到了问题，因为我的脚本是从符号链接目录操作的，或者至少这就是为什么我认为上述解决方案对我不起作用的原因。按照 @ennuikiller 的回答，我把我的 Rscript 包装在 bash 中。我使用 设置路径变量，它解析符号链接的目录结构。然后将路径传递到 Rscript 中。pwd -P

Bash.sh

#!/bin/bash

# set path variable
path=`pwd -P`

#Run Rscript with path argument
Rscript foo.R $path

呸呸。R

args <- commandArgs(trailingOnly=TRUE)
setwd(args[1])
source(other.R)

我喜欢 steamer25 的解决方案，因为它似乎对我的目的来说是最强大的。但是，在 RStudio 中（在 Windows 中）进行调试时，路径将无法正确设置。原因是，如果在 RStudio 中设置了断点，则使用备用的“调试源”命令来获取文件，该命令将脚本路径设置略有不同。这是我当前使用的最终版本，它在调试时考虑了 RStudio 中的这种替代行为：

# @return full path to this script
get_script_path <- function() {
    cmdArgs = commandArgs(trailingOnly = FALSE)
    needle = "--file="
    match = grep(needle, cmdArgs)
    if (length(match) > 0) {
        # Rscript
        return(normalizePath(sub(needle, "", cmdArgs[match])))
    } else {
        ls_vars = ls(sys.frames()[[1]])
        if ("fileName" %in% ls_vars) {
            # Source'd via RStudio
            return(normalizePath(sys.frames()[[1]]$fileName)) 
        } else {
            # Source'd via R console
            return(normalizePath(sys.frames()[[1]]$ofile))
        }
    }
}

我会使用@steamer25方法的变体。关键是，即使我的会话是通过 Rscript 启动的，我也更喜欢获取最后一个源脚本。以下代码片段包含在文件中时，将提供一个包含脚本规范化路径的变量。 我承认（滥用）使用源，所以有时我调用 Rscript，参数中提供的脚本 source 另一个脚本，该脚本源另一个脚本......总有一天，我会投资把我凌乱的代码变成一个包。thisScript--file

thisScript <- (function() {
  lastScriptSourced <- tail(unlist(lapply(sys.frames(), function(env) env$ofile)), 1)

  if (is.null(lastScriptSourced)) {
    # No script sourced, checking invocation through Rscript
    cmdArgs <- commandArgs(trailingOnly = FALSE)
    needle <- "--file="
    match <- grep(needle, cmdArgs)
    if (length(match) > 0) {
      return(normalizePath(sub(needle, "", cmdArgs[match]), winslash=.Platform$file.sep, mustWork=TRUE))
    }
  } else {
    # 'source'd via R console
    return(normalizePath(lastScriptSourced, winslash=.Platform$file.sep, mustWork=TRUE))
  }
})()

获取 R 脚本路径的 rakensi 的答案是最正确和非常出色的恕我直言。然而，它仍然是一个包含虚拟功能的黑客。我在这里引用它，为了让其他人更容易找到它。

sourceDir <- getSrcDirectory（function（dummy） {dummy}）

这给出了放置语句的文件的目录（定义虚拟函数的位置）。然后，它可用于设置工作方向并使用相对路径，例如

setwd(sourceDir)
source("other.R")

或创建绝对路径

 source(paste(sourceDir, "/other.R", sep=""))

我的多合一！（--01/09/2019 更新以处理 RStudio 控制台）

#' current script file (in full path)
#' @description current script file (in full path)
#' @examples
#' works with Rscript, source() or in RStudio Run selection, RStudio Console
#' @export
ez.csf <- function() {
    # http://stackoverflow.com/a/32016824/2292993
    cmdArgs = commandArgs(trailingOnly = FALSE)
    needle = "--file="
    match = grep(needle, cmdArgs)
    if (length(match) > 0) {
        # Rscript via command line
        return(normalizePath(sub(needle, "", cmdArgs[match])))
    } else {
        ls_vars = ls(sys.frames()[[1]])
        if ("fileName" %in% ls_vars) {
            # Source'd via RStudio
            return(normalizePath(sys.frames()[[1]]$fileName))
        } else {
            if (!is.null(sys.frames()[[1]]$ofile)) {
            # Source'd via R console
            return(normalizePath(sys.frames()[[1]]$ofile))
            } else {
                # RStudio Run Selection
                # http://stackoverflow.com/a/35842176/2292993
                pth = rstudioapi::getActiveDocumentContext()$path
                if (pth!='') {
                    return(normalizePath(pth))
                } else {
                    # RStudio Console
                    tryCatch({
                            pth = rstudioapi::getSourceEditorContext()$path
                            pth = normalizePath(pth)
                        }, error = function(e) {
                            # normalizePath('') issues warning/error
                            pth = ''
                        }
                    )
                    return(pth)
                }
            }
        }
    }
}

我只是自己解决了这个问题。为确保脚本的可移植性，请始终以以下开头：

wd <- setwd(".")
setwd(wd)

它之所以有效，是因为“.”的翻译方式类似于 Unix 命令$PWD。将此字符串分配给字符对象允许您将该字符对象插入到 setwd（） 中，并且 Presto 您的代码将始终以其当前目录作为工作目录运行，无论它在谁的机器上或位于文件结构中的哪个位置。（额外的好处：wd 对象可以与 file.path（） 一起使用（即 file.path（wd， “output_directory”），以允许创建标准输出目录，而不管指向命名目录的文件路径如何。这确实要求您在以这种方式引用新目录之前创建新目录，但这也可以通过 wd 对象来帮助。

或者，以下代码执行完全相同的操作：

wd <- getwd()
setwd(wd)

或者，如果您不需要对象中的文件路径，您可以简单地：

setwd(".")

99% 的情况，您可以简单地使用：

sys.calls()[[1]] [[2]]

它不适用于脚本不是第一个参数的疯狂调用，即 .在这些花哨的情况下使用@hadley。source(some args, file="myscript")

请注意，getopt 包提供了该函数，该函数仅使用此处介绍的相同解决方案，但已在标准 R 模块中为您编写，因此您不必将“获取脚本路径”函数复制并粘贴到您编写的每个脚本中。get_Rscript_filename

Steamer25 的方法有效，但前提是路径中没有空格。至少在 macOS 上，返回类似 for 的内容。cmdArgs[match]/base/some~+~dir~+~with~+~whitespace//base/some\ dir\ with\ whitespace/

我通过在返回之前用简单的空格替换“~+~”来解决这个问题。

thisFile <- function() {
  cmdArgs <- commandArgs(trailingOnly = FALSE)
  needle <- "--file="
  match <- grep(needle, cmdArgs)
  if (length(match) > 0) {
    # Rscript
    path <- cmdArgs[match]
    path <- gsub("\\~\\+\\~", " ", path)
    return(normalizePath(sub(needle, "", path)))
  } else {
    # 'source'd via R console
    return(normalizePath(sys.frames()[[1]]$ofile))
  }
}

显然，您仍然可以像 aprstar 那样扩展 else 块。

这对我有用

library(rstudioapi)    
rstudioapi::getActiveDocumentContext()$path

如果不是脚本，而是知道它的路径位置，如果你可以更改你的代码，以始终引用公共的所有路径，那么这些可能会有很大的帮助：foo.Rsourceroot

• https://github.com/r-lib/rprojroot 或 https://rprojroot.r-lib.org/
• https://here.r-lib.org/

鉴于

• /app/deeply/nested/foo.R
• /app/other.R

这将起作用

#!/usr/bin/env Rscript
library(here)
source(here("other.R"))

有关如何定义项目根目录，请参见 https://rprojroot.r-lib.org/。

令人惊讶的是，R 中没有“$0”类型的结构！你可以通过对用 R 编写的 bash 脚本进行 system（） 调用来做到这一点：

write.table(c("readlink -e $0"), file="scriptpath.sh",col=F, row=F, quote=F)
thisscript <- system("sh scriptpath.sh", intern = TRUE)

然后只需将 scriptpath.sh 名称拆分为其他名称。R

splitstr <- rev(strsplit(thisscript, "\\/")[[1]])
otherscript <- paste0(paste(rev(splitstr[2:length(splitstr)]),collapse="/"),"/other.R")

我几乎尝试了这个问题中的所有内容，获取R脚本的路径，获取当前脚本的路径，查找当前脚本的位置。 R 文件和 R 命令，用于在 Rstudio 中将工作目录设置为源文件位置，但最后发现自己手动浏览了 CRAN 表并发现

scriptName 库

它提供函数，当在 RStudio 中查找时以及通过 R 或 RScript 可执行文件调用时，该函数返回脚本的正确完整路径。current_filename()

通过查看调用堆栈，我们可以获取每个正在执行的脚本的文件路径，其中两个最有用的可能是当前正在执行的脚本，或者是要获取的第一个脚本（条目）。

script.dir.executing = (function() return( if(length(sys.parents())==1) getwd() else dirname( Filter(is.character,lapply(rev(sys.frames()),function(x) x$ofile))[[1]] ) ))()

script.dir.entry = (function() return( if(length(sys.parents())==1) getwd() else dirname(sys.frame(1)$ofile) ))()

我也有这个问题，以上解决方案都不适合我。也许有或类似的东西，但还不够清楚。source

我发现这个，对我来说，优雅的解决方案：

paste0(gsub("\\", "/", fileSnapshot()$path, fixed=TRUE),"/")

重要的是它为您提供了有关文件的大量信息。它返回一个包含 8 个元素的列表。当您选择作为列表元素时，路径将返回为分隔符，因此代码的其余部分只是为了更改它。fileSnapshot()path\\

我希望这会有所帮助。

我在 HPC 集群环境中工作。我在与生产运行位置不同的位置开发代码。在开发过程中，我通常从命令行以交互方式调用 R（不使用 RStudio）。有很多事情正在发生。source("foo.R")

在生产运行期间，我通常会编写一个 bash 脚本来尝试不同的参数，并在单独的目录中运行每组参数。bash 脚本使用工作负载管理器（即 SLURM）。在这种环境下，设置环境变量是微不足道的。考虑到这一点，以下解决方案最适合我。

其他。R

my_message <- function(){
return("R is awkward")
}

呸呸。R

srcpath = Sys.getenv("R_SRC")
# Check if runnning w/o setting R_SRC - presumably done in directory of development, i.e. /path/to/R/code
if(srcpath == ""){
    srcpath="./"
}
source(sprintf("%s/other.R", srcpath))
string = my_message()
print(string)

如果从 R 交互式 shell 和 中运行它，只需执行/path/to/R/code

> source("foo.R")

如果不是从交互式 shell 运行，也不是从 运行，请先设置环境变量，然后调用/path/to/R/codeR_SRCRscript

$ export R_SRC=/path/to/R/code/
$ Rscript /path/to/R/code/foo.R

我为此制作了一个包，可在 CRAN 和 GitHub 上找到，称为 this.path。当前版本为 2.3.1 （2023-12-10），您可以在此处找到它：

https://CRAN.R-project.org/package=this.path

https://github.com/ArcadeAntics/this.path

从 CRAN 安装它：

utils::install.packages("this.path")

或从 GitHub 安装开发版本：

utils::install.packages("this.path",
    repos = "https://raw.githubusercontent.com/ArcadeAntics/PACKAGES")

然后通过以下方式使用它：

this.path::this.path()

艺术

library(this.path)
this.path()

下面的答案是我的原始答案，仅供参考，尽管它的功能比上面可用的最新版本要少得多。改进包括：

• 兼容更多 GUI：Windows 上的“Rgui”、“VSCode”、“Jupyter”和“Emacs”+“ESS”'
• 与软件包 compiler、box、knitr、plumber、shiny、targets 和 testthat 的兼容性，特别是 、 、 、 和compiler::loadcmp()box::use()knitr::knit()plumber::plumb()shiny::runApp()testthat::source_file()
• 在 Unix-alikes 下从 shell 运行 R 脚本时处理带空格的文件名
• 处理从 shell 运行 R 脚本的两种用法（和-fFILE--file=FILE)
• 与参数一起使用时正确规范化路径source()(chdir = TRUE)
• 处理带有 such as 和 的文件 URIsource()source("file:///path/to/file")source("file:///C:/path/to/file")
• 改进了对连接而不是字符串的处理source()
• 中 URL 路径名的处理，即：source()

source("https://host/path/to/file")

如果在文件中使用，它将返回 .这也适用于以 、 和 开头的 URL。例如，尝试：this.path()"https://host/path/to/file""http://""ftp://""ftps://"

source("https://raw.githubusercontent.com/ArcadeAntics/this.path/main/tests/this.path_w_URLs.R")

• 引入函数 / / ，类似于 ，用于指定相对于执行脚本目录的绝对文件路径 / / 执行脚本的项目根目录here()this.proj()here::here()
• 在脚本中首次调用规范化路径时，将规范化路径保存在其适当的环境中，从而可以更快地在同一脚本中使用后续时间，并且独立于工作目录。这意味着它将不再中断（只要在该脚本中第一次调用后使用）this.path()setwd()this.path()setwd()this.path()

原答案：

我的回答是对 Jerry T 的回答的改进。我发现的问题是，他们通过检查是否在堆栈的第一帧中找到变量来猜测是否进行了调用。这不适用于嵌套的源调用，也不适用于从非全局环境进行的源调用。此外，顺序错误。在检查 shell 参数之前，我们必须查找源调用。这是我的解决方案：source()ofile

this.path <- function (verbose = getOption("verbose"))
{
    ## loop through functions that lead here from most recent to
    ## earliest looking for an appropriate source call (a call to
    ## function source / / sys.source / / debugSource in RStudio)
    ##
    ## an appropriate source call is one in which the file argument has
    ## been evaluated (forced)
    ##
    ## for example, `source(this.path())` is an inappropriate source
    ## call. argument 'file' is stored as a promise containing the
    ## expression `this.path()`. when 'file' is requested,
    ## the expression is evaluated at which time there should be two
    ## functions on the calling stack being 'source' and 'this.path'.
    ## clearly, you don't want to request the 'file' argument from that
    ## source call because the value of 'file' is under evaluation
    ## right now! the trick is to ask if 'file' has already been
    ## evaluated, the easiest way of which is to ask if a variable
    ## exists, one which is only created after the expression is
    ## necessarily evaluated.
    ##
    ## if that variable does exist, then argument 'file' has been
    ## forced and the source call is deemed appropriate. otherwise,
    ## the source call is deemed inappropriate and the 'for' loop
    ## moves to the next function up the calling stack
    ##
    ## unfortunately, there is no way to check the argument 'fileName'
    ## has been forced for 'debugSource' since all the work is done
    ## internally in C. Instead, we have to use a 'tryCatch' statement.
    ## When we evaluate a promise, R is capable of realizing if a
    ## variable is asking for its own definition (a recursive promise).
    ## The error is "promise already under evaluation" which indicates
    ## that the promise is requesting its own value. So we use the
    ## 'tryCatch' to get 'fileName' from the evaluation environment of
    ## 'debugSource', and if it does not raise an error, then we are
    ## safe to return that value. If not, the condition returns false
    ## and the 'for' loop moves to the next function up the calling
    ## stack


    debugSource <- if (.Platform$GUI == "RStudio")
        get("debugSource", "tools:rstudio", inherits = FALSE)
    for (n in seq.int(to = 1L, by = -1L, length.out = sys.nframe() - 1L)) {
        if (identical(sys.function(n), source) &&
            exists("ofile", envir = sys.frame(n), inherits = FALSE))
        {
            path <- get("ofile", envir = sys.frame(n), inherits = FALSE)
            if (!is.character(path))
                path <- summary.connection(path)$description
            if (verbose)
                cat("Source: call to function source\n")
            return(normalizePath(path, "/", TRUE))
        }
        else if (identical(sys.function(n), sys.source) &&
                 exists("exprs", envir = sys.frame(n), inherits = FALSE))
        {
            path <- get("file", envir = sys.frame(n), inherits = FALSE)
            if (verbose)
                cat("Source: call to function sys.source\n")
            return(normalizePath(path, "/", TRUE))
        }
        else if (identical(sys.function(n), debugSource) &&
                 tryCatch({
                     path <- get("fileName", envir = sys.frame(n), inherits = FALSE)
                     TRUE
                 }, error = function(c) FALSE))
        {
            if (verbose)
                cat("Source: call to function debugSource in RStudio\n")
            return(normalizePath(path, "/", TRUE))
        }
    }


    ## no appropriate source call was found up the calling stack


    ## running from RStudio
    if (.Platform$GUI == "RStudio") {


        ## ".rs.api.getSourceEditorContext" from "tools:rstudio"
        ## returns a list of information about the document open in the
        ## current tab
        ##
        ## element 'path' is a character string, the document's path


        context <- get(".rs.api.getSourceEditorContext",
            "tools:rstudio", inherits = FALSE)()
        if (is.null(context))
            stop("R is running from RStudio with no documents open\n",
                 " (or document has no path)")


        path <- context[["path"]]
        if (nzchar(path)) {
            Encoding(path) <- "UTF-8"
            if (verbose)
                cat("Source: document in RStudio\n")
            return(normalizePath(path, "/", TRUE))
        }
        else stop("document in RStudio does not exist")
    }


    ## running from a shell
    else if (.Platform$OS.type == "windows" && .Platform$GUI == "RTerm" ||  ## on Windows
             .Platform$OS.type == "unix"    && .Platform$GUI == "X11")      ## under Unix-alikes
    {


        argv <- commandArgs()
        ## remove all trailing arguments
        m <- match("--args", argv, 0L)
        if (m)
            argv <- argv[seq_len(m)]
        argv <- argv[-1L]


        ## get all arguments starting with "--file="
        FILE <- argv[startsWith(argv, "--file=")]
        ## remove "--file=" from the start of each string
        FILE <- substring(FILE, 8L)
        ## remove strings "-"
        FILE <- FILE[FILE != "-"]
        n <- length(FILE)
        if (n) {
            FILE <- FILE[[n]]
            if (verbose)
                cat("Source: shell argument 'FILE'\n")
            return(normalizePath(FILE, "/", TRUE))
        } else {
            stop("R is running from a shell and argument 'FILE' is missing")
        }
    }


    ## running from RGui on Windows
    else if (.Platform$OS.type == "windows" && .Platform$GUI == "Rgui") {
        stop("R is running from Rgui which is currently unimplemented\n",
             " consider using RStudio until such a time when this is implemented")
    }


    ## running from RGui on macOS
    else if (.Platform$OS.type == "unix" && .Platform$GUI == "AQUA") {
        stop("R is running from AQUA which is currently unimplemented\n",
             " consider using RStudio until such a time when this is implemented")
    }


    ## otherwise
    else stop("R is running in an unrecognized manner")
}

该解决方案于 2016 年问世。非常感谢作者Sahil Seth！

CRAN 和 github 上的包提供了获取当前脚本完整路径的函数。它甚至引用了类似的 SO 帖子。funrsys.script()

因此，解决方案是：

myscript。R:

#!/usr/bin/env Rscript
f  <-  funr::sys.script()
show(f)

然后执行命令：

user@somewhere:/home$ Rscript myscript.R

在命令行将输出，例如：

"/home/path/to/myscript.R"

到控制台。

只是为了在上述答案的基础上，作为安全检查，您可以添加一个包装器，要求用户在（无论出于何种原因）失败（如果）失败时找到文件，或者源脚本不在主脚本预期的位置。sys.frame(1)interactive() == TRUE

fun_path = tryCatch(expr = 
                      {file.path(dirname(sys.frame(1)$ofile), "foo.R")},
                    error = function(e){'foo.R'}
                    )
if(!file.exists(fun_path))
{
  msg = 'Please select "foo.R"'
  # ask user to find data
  if(Sys.info()[['sysname']] == 'Windows'){#choose.files is only available on Windows
    message('\n\n',msg,'\n\n')
    Sys.sleep(0.5)#goes too fast for the user to see the message on some computers
    fun_path  = choose.files(
      default = file.path(gsub('\\\\', '/', Sys.getenv('USERPROFILE')),#user
                          'Documents'),
      caption = msg
    )
  }else{
    message('\n\n',msg,'\n\n')
    Sys.sleep(0.5)#goes too fast for the user to see the message on some computers
    fun_path = file.choose(new=F)
  }
}
#source the function
source(file = fun_path, 
       encoding = 'UTF-8')

我发现最灵活的解决方案是利用和（可选）rstudioapi::getSourceEditorContext()sub()

• 以交互方式为两者工作。Rmd 和 .R 脚本
• 在编织时有效。Rmd 文件
• 在采购 .R 文件

请尝试以下操作：

current_file <-
  rstudioapi::getSourceEditorContext()$path %>%
  sub(".*/", "", .)

返回当前文件的完整路径rstudioapi::getSourceEditorContext()$path

提取最后一个之后的所有内容，只留下文件的名称。sub(".*/", "", .)/

我希望这会有所帮助！