Bestimmen Sie den Pfad des ausführenden Skripts

Ich habe ein Skript namens foo.R, das ein anderes Skript enthält other.R, das sich im selben Verzeichnis befindet:

#!/usr/bin/env Rscript
message("Hello")
source("other.R")

Aber ich möchte Rdas finden, other.Regal was das aktuelle Arbeitsverzeichnis ist.

Mit anderen Worten, foo.Rmuss seinen eigenen Weg kennen. Wie kann ich das machen?

Hier gibt es eine einfache Lösung für das Problem. Dieser Befehl:

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

Gibt den Pfad der aktuellen Skriptdatei zurück. Es funktioniert, nachdem das Skript gespeichert wurde.

Mit der commandArgsFunktion können Sie alle Optionen abrufen, die von Rscript an den eigentlichen R-Interpreter übergeben wurden, und nach ihnen suchen --file=. Wenn Ihr Skript über den Pfad gestartet wurde oder wenn es mit einem vollständigen Pfad gestartet wurde, script.namebeginnt das Folgende mit einem '/'. Andernfalls muss es relativ zu sein cwdund Sie können die beiden Pfade zusammenfassen, um den vollständigen Pfad zu erhalten.

Bearbeiten: Es hört sich so an, als würden Sie nur das script.nameObige benötigen und die letzte Komponente des Pfades entfernen. Ich habe das nicht benötigte cwd()Beispiel entfernt, das Hauptskript bereinigt und mein other.R. Speichern Sie dieses Skript und das other.RSkript einfach im selben Verzeichnis chmod +xund führen Sie das Hauptskript aus.

main.R :

#!/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)

other.R :

print("hello")

Ausgabe :

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"

Ich glaube, das ist es, wonach Dehmann sucht.

Ich konnte die Lösung von Suppressingfire nicht zum Laufen bringen, wenn ich von der R-Konsole aus "quelle".
Ich konnte Hadleys Lösung nicht zum Laufen bringen, wenn ich Rscript verwendete.

Beste aus beiden Welten?

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

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

Frag mich aber nicht, wie es funktioniert, denn ich habe vergessen: /

Das funktioniert bei mir

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

Die Antwort von Rakensi aus dem Pfad eines R-Skripts ist meiner Meinung nach die korrekteste und wirklich brillanteste. Dennoch ist es immer noch ein Hack mit einer Dummy-Funktion. Ich zitiere es hier, damit es von anderen leichter gefunden wird.

sourceDir <- getSrcDirectory (Funktion (Dummy) {Dummy})

Dies gibt das Verzeichnis der Datei an, in der die Anweisung platziert wurde (in der die Dummy-Funktion definiert ist). Es kann dann verwendet werden, um das Arbeitsverzeichnis festzulegen und relative Pfade zu verwenden, z

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

oder um absolute Pfade zu erstellen

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

Mein alles in einem! (--01 / 09/2019 aktualisiert, um mit RStudio Console umzugehen)

#' 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)
                }
            }
        }
    }
}

Eine abgespeckte Variante von Supressingfires Antwort:

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

Das funktioniert bei mir. Greift es einfach aus den Befehlszeilenargumenten heraus, entfernt den unerwünschten Text, macht einen Verzeichnisnamen und erhält schließlich den vollständigen Pfad daraus:

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

Ich habe die Antworten auf diese Frage in eine neue Funktion thisfile()in rprojroot eingepackt und erweitert . Funktioniert auch zum Stricken mit knitr.

Ich mochte die Lösung von steamer25, da sie für meine Zwecke am robustesten erscheint. Beim Debuggen in RStudio (in Windows) wurde der Pfad jedoch nicht richtig festgelegt. Der Grund dafür ist, dass bei der Festlegung eines Haltepunkts in RStudio für die Beschaffung der Datei ein alternativer Befehl "Debug-Quelle" verwendet wird, mit dem der Skriptpfad etwas anders festgelegt wird. Hier ist die endgültige Version, die ich derzeit verwende und die dieses alternative Verhalten in RStudio beim Debuggen berücksichtigt:

# @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))
        }
    }
}

Ich habe fast alles aus dieser Frage heraus versucht: Pfad eines R-Skripts abrufen , Pfad des aktuellen Skripts abrufen , Speicherort der aktuellen R-Datei suchen und R-Befehl zum Festlegen des Arbeitsverzeichnisses auf den Speicherort der Quelldatei in Rstudio , aber am Ende fand ich mich manuell Durchsuchen der CRAN-Tabelle und gefunden

scriptName Bibliothek

current_filename()Dies bietet eine Funktion, die beim Sourcing in RStudio und auch beim Aufrufen über die ausführbare Datei R oder RScript den richtigen vollständigen Pfad des Skripts zurückgibt.

Ich hatte auch dieses Problem und keine der oben genannten Lösungen funktionierte für mich. Vielleicht mit dem sourceoder solchen Dingen, aber es war nicht klar genug.

Ich fand diese für mich elegante Lösung:

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

Das Wichtigste dabei ist, fileSnapshot()dass Sie viele Informationen über eine Datei erhalten. Es wird eine Liste mit 8 Elementen zurückgegeben. Wenn Sie pathals Listenelement auswählen , wird der Pfad \\als Trennzeichen zurückgegeben, sodass der Rest des Codes nur dazu dient, dies zu ändern.

Ich hoffe das hilft.

Sie können das r-Skript in ein Bash-Skript einschließen und den Pfad des Skripts als Bash-Variable wie folgt abrufen:

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

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

     EOF

Ich mag diesen Ansatz:

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

Ich habe das einfach selbst herausgefunden. Um die Portabilität Ihres Skripts sicherzustellen, beginnen Sie immer mit:

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

Es funktioniert, weil "." übersetzt wie der Unix-Befehl $ PWD. Wenn Sie diese Zeichenfolge einem Zeichenobjekt zuweisen, können Sie dieses Zeichenobjekt in setwd () einfügen. Presto Ihr Code wird immer mit seinem aktuellen Verzeichnis als Arbeitsverzeichnis ausgeführt, unabhängig davon, auf welchem ​​Computer er sich befindet oder wo in der Dateistruktur er sich befindet gelegen. (Zusätzlicher Bonus: Das wd-Objekt kann mit file.path () (dh file.path (wd, "output_directory") verwendet werden, um unabhängig vom Dateipfad, der zu Ihrem benannten Verzeichnis führt, ein Standardausgabeverzeichnis zu erstellen. Dazu müssen Sie das neue Verzeichnis erstellen, bevor Sie es auf diese Weise referenzieren. Dies kann jedoch auch mit dem wd-Objekt unterstützt werden.

Alternativ führt der folgende Code genau dasselbe aus:

wd <- getwd()
setwd(wd)

Wenn Sie den Dateipfad in einem Objekt nicht benötigen, können Sie einfach:

setwd(".")

Beachten Sie, dass das getopt-Paket die get_Rscript_filenameFunktion bereitstellt , die nur die hier vorgestellte Lösung verwendet, jedoch bereits in einem Standard-R-Modul für Sie geschrieben wurde, sodass Sie die Funktion "get script path" nicht in jedes Skript kopieren und einfügen müssen du schreibst.

Siehe findSourceTraceback()das R.utils- Paket, das

Findet alle von source () generierten 'srcfile'-Objekte in allen Aufrufrahmen. Auf diese Weise können Sie herausfinden, welche Dateien derzeit von source () gescriptet werden.

Ich hatte Probleme mit den oben genannten Implementierungen, da mein Skript von einem Symlink-Verzeichnis aus betrieben wird, oder zumindest denke ich, dass die oben genannten Lösungen für mich nicht funktioniert haben. In Anlehnung an die Antwort von @ ennuikiller habe ich mein Rscript in Bash eingewickelt. Ich setze die pwd -PPfadvariable mit , die symlinked Verzeichnisstrukturen auflöst. Übergeben Sie dann den Pfad in das Rscript.

Bash.sh

#!/bin/bash

# set path variable
path=`pwd -P`

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

foo.R

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

Ich würde eine Variante des Ansatzes von @ steamer25 verwenden. Der Punkt ist, dass ich es vorziehen würde, das Skript mit der letzten Quelle zu erhalten, selbst wenn meine Sitzung über Rscript gestartet wurde. Das folgende Snippet enthält, wenn es in einer Datei enthalten ist, eine Variable, thisScriptdie den normalisierten Pfad des Skripts enthält. Ich gestehe die (ab) Verwendung von source'ing, deshalb rufe ich manchmal Rscript auf und das im --fileArgument angegebene Skript liefert ein anderes Skript, das ein anderes liefert ... Eines Tages werde ich investieren, um meinen unordentlichen Code in ein Paket zu verwandeln.

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

99% der Fälle könnten Sie einfach verwenden:

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

Es funktioniert nicht für verrückte Anrufe, bei denen das Skript nicht das erste Argument ist, d source(some args, file="myscript"). H. Verwenden Sie @ hadley in diesen ausgefallenen Fällen.

Der Ansatz von Steamer25 funktioniert, jedoch nur, wenn der Pfad kein Leerzeichen enthält. Unter macOS gibt das zumindest so cmdArgs[match]etwas wie /base/some~+~dir~+~with~+~whitespace/für zurück /base/some\ dir\ with\ whitespace/.

Ich habe dies umgangen, indem ich das "~ + ~" durch ein einfaches Leerzeichen ersetzt habe, bevor ich es zurückgegeben habe.

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

Natürlich können Sie den else-Block immer noch wie aprstar erweitern.

Wenn Sie anstelle des Skripts, foo.Rwenn Sie dessen Pfadposition kennen, Ihren Code so ändern können, dass er immer auf alle sourced-Pfade eines gemeinsamen Pfads verweist , rootkönnen diese eine große Hilfe sein:

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

Gegeben

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

Das wird funktionieren

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

Informationen zum Definieren von Projektwurzeln finden Sie unter https://rprojroot.r-lib.org/ .

#!/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='/'))

Erstaunlich, dass es in R keine Struktur vom Typ '$ 0' gibt! Sie können dies mit einem system () -Aufruf eines in R geschriebenen Bash-Skripts tun:

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

Teilen Sie dann einfach den Namen scriptpath.sh für other.R auf

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

Wenn wir uns den Aufrufstapel ansehen, können wir den Dateipfad jedes ausgeführten Skripts ermitteln. Die beiden nützlichsten sind wahrscheinlich entweder das aktuell ausgeführte Skript oder das erste Skript, das bezogen wird (Eintrag).

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