Yürütme komut dosyasının yolunu belirleme

Aynı dizinde foo.Rbaşka bir komut dosyası içeren adlı bir komut dosyası var other.R:

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

Ama bunu Rbulmak istiyorumother.R şu anki çalışma dizini ne olursa olsun .

Başka bir deyişle, foo.Rkendi yolunu bilmek gerekir. Bunu nasıl yapabilirim?

Burada problem için basit bir çözüm var. Bu komut:

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

geçerli kod dosyasının yolunu döndürür. Komut dosyası kaydedildikten sonra çalışır.

Bu commandArgsişlevi, Rscript tarafından gerçek R yorumlayıcısına iletilen tüm seçenekleri almak ve aramak için kullanabilirsiniz --file=. Betiğiniz yoldan başlatılmışsa veya tam yolla başlatılmışsa, script.nameaşağıdakiler bir ile başlayacaktır '/'. Aksi takdirde, göreli olmalıdır cwdve tam yolu elde etmek için iki yolu birleştirebilirsiniz.

Düzenleme: Görünüşe göre yalnızca script.nameyukarıdakilere ihtiyacınız var ve yolun son bileşenini kaldırıyorsunuz. Gereksiz cwd()örneği kaldırdım ve ana komut dosyasını temizledim ve yayınladım other.R. Bu komut dosyasını ve other.Rkomut dosyasını aynı dizine kaydedin chmod +xve ana komut dosyasını çalıştırın.

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

diğer R :

print("hello")

çıktı :

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'ın aradığına inanıyorum.

Suppressingfire'ın çözümünü R konsolundan 'kaynak' yaparken işe yarayamadım.
Rscript kullanırken hadley'nin çözümünü alamadım.

Her iki dünyanın en iyisi?

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

Bana nasıl çalıştığını sorma çünkü unuttum: /

Bu benim için çalışıyor

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

Bir R betiğinin yolunu almaktan gelen rakensi'nin cevabı en doğru ve gerçekten parlak IMHO'dur. Yine de, kukla bir işlev içeren bir hack. Başkaları tarafından daha kolay bulunabilmesi için burada alıntı yapıyorum.

sourceDir <- getSrcDirectory (işlev (kukla) {kukla})

Bu, ifadenin yerleştirildiği (kukla fonksiyonun tanımlandığı yer) dosyanın dizinini verir. Daha sonra çalışan direcory'yi ayarlamak ve göreli yolları kullanmak için kullanılabilir, örn.

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

veya mutlak yollar oluşturmak için

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

Hepsi bir arada! (--01 / 09/2019, RStudio Konsolu ile başa çıkmak için güncellendi)

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

Supressingfire'ın cevabının zayıflamış bir çeşidi:

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

Bu benim için çalışıyor. Sadece komut satırı argümanlarından çıkarır, istenmeyen metni çıkarır, bir dirname yapar ve sonunda tam yolu bundan alır:

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

Ben sarılmış ve yeni bir fonksiyon bu soruya cevap artırdık thisfile()içinde rprojroot . Ayrıca örme için de çalışır knitr.

Steamer25'in çözümünü sevdim, çünkü amacım için en sağlam görünüyor. Ancak, RStudio'da (pencerelerde) hata ayıklama yaparken, yol düzgün ayarlanmaz. Bunun nedeni RStudio'da bir kesme noktası ayarlanırsa, dosyayı kaynaklamak için komut dosyasının yolunu biraz farklı ayarlayan alternatif bir "hata ayıklama kaynağı" komutu kullanılır. Şu anda hata ayıklama sırasında RStudio içinde bu alternatif davranış için hangi hesapları kullandığım son sürümü:

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

Ben, bu soruya neredeyse her şeyi denedim bir R script yolunu alma , şimdiki komut yolunu alın , cari .R dosyasının konumunu bulun ve Rstudio kaynak dosya konumuna çalışma dizinini ayarlamak için R komutu , ama sonunda el buldum CRAN tablosuna göz atıldı ve bulundu

scriptName kütüphane

current_filename()RStudio'da kaynak oluştururken ve ayrıca R veya RScript yürütülebilir dosyası aracılığıyla çağırırken komut dosyasının tam yolunu döndüren işlev sağlar .

Ben de bu sorunu yaşadım ve yukarıdaki çözümlerin hiçbiri benim için işe yaramadı. Belkisource ya da bunun gibi şeylerle, ama yeterince açık değildi.

Bunu benim için zarif buldum:

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

Buradaki önemli şey, fileSnapshot()bir dosya hakkında size çok fazla bilgi vermesidir. 8 elemanlık bir liste döndürür. pathListe öğesi olarak seçtiğinizde , yol\\ ayırıcı olarak , bu nedenle kodun geri kalanı bunu değiştirmek içindir.

Umarım bu yardımcı olur.

R komut dosyasını bir bash komut dosyasına sarabilir ve komut dosyasının yolunu aşağıdaki gibi bir bash değişkeni olarak alabilirsiniz:

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

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

     EOF

Bu yaklaşımı seviyorum:

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

Bunu kendim hallettim. Komut dosyanızın taşınabilirliğini sağlamak için her zaman şunlarla başlayın:

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

Çalışıyor çünkü "." $ PWD Unix komutu gibi çevirir. Bir karakter nesnesine Bu dize Atama sonra setwd () ve içine karakter nesneyi eklemek sağlar Presto kodunuz, kimin makinesinde olduğu veya dosya yapısında nerede olursa olsun, her zaman geçerli dizini çalışma dizini olarak çalıştıracaktır. yer. (Ek bonus: wd nesnesi, adlandırılmış dizininize giden dosya yolundan bağımsız olarak standart bir çıktı dizini oluşturulmasına izin vermek için file.path () (yani. File.path (wd, "output_directory") ile kullanılabilir. Bu, yeni dizini bu şekilde referans vermeden önce yapmanızı gerektirir, ancak wd nesnesine de yardımcı olabilir.

Alternatif olarak, aşağıdaki kod aynı şeyi gerçekleştirir:

wd <- getwd()
setwd(wd)

veya bir nesnede dosya yoluna ihtiyacınız yoksa şunları yapabilirsiniz:

setwd(".")

Getopt paketinin get_Rscript_filenameburada sunulan aynı çözümü kullanan ancak sizin için zaten standart bir R modülünde yazılmış olan işlevi sağladığını unutmayın , böylece "script yolunu al" işlevini her komut dosyasına kopyalayıp yapıştırmanız gerekmez Sen yaz.

R.utils paketine bakınız findSourceTraceback().

Tüm çağrı çerçevelerinde source () tarafından oluşturulan tüm 'srcfile' nesnelerini bulur. Bu, hangi dosyaların şu anda source () tarafından kodlandığını bulmayı mümkün kılar.

Komut dosyam symlinkink bir dizinden çalıştırıldığı için yukarıdaki uygulamalar ile ilgili sorunlar yaşadım, ya da en azından bu yüzden yukarıdaki çözümlerin benim için çalışmadığını düşünüyorum. @ Ennuikiller'in yanıtı boyunca, Rscriptimi bash'a tamamladım. pwd -PSymlinked dizin yapılarını çözen yol değişkenini kullanarak ayarladım . Sonra yolu Rscript'e geçirin.

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)

@ Steamer25'in yaklaşımının bir varyantını kullanırdım. Asıl nokta, oturumum Rscript ile başlatıldığında bile son kaynaklı komut dosyasını almayı tercih etmem. Aşağıdaki snippet, bir dosyaya dahil edildiğinde thisScript, komut dosyasının normal yolunu içeren bir değişken sağlayacaktır . Ben kaynak '(ab) kullanımı itiraf, bu yüzden bazen Rscript ve --fileargüman sağlanan komut dosyası başka bir kaynak başka bir komut dosyası çağırmak ... Bir gün dağınık kodumu bir pakete dönüştürmek için yatırım yapacak.

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

Kullanabileceğiniz vakaların% 99'u:

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

Komut dosyasının ilk argüman olmadığı çılgın çağrılar için çalışmaz, yani source(some args, file="myscript"). Bu süslü durumlarda @ hadley kullanın.

Steamer25'in yaklaşımı işe yarar, ancak yolda hiçbir boşluk yoksa. MacOS üzerinde en azından cmdArgs[match]gibi döner bir şey /base/some~+~dir~+~with~+~whitespace/için /base/some\ dir\ with\ whitespace/.

Geri dönmeden önce "~ + ~" basit bir boşluk ile değiştirerek bu konuda çalıştı.

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

Açıkçası yine de aprstar gibi diğer bloğu genişletebilirsiniz.

Komut dosyası yerine foo.R, yol konumunu bilmek, kodunuzu her zaman sourceortak bir yoldan tüm referans alanlarına başvuracak şekilde değiştirebilirseniz, rootbunlar büyük bir yardımcı olabilir:

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

verilmiş

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

Bu çalışacak

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

Proje köklerini nasıl tanımlayacağınız için https://rprojroot.r-lib.org/ adresine bakın .

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

Şaşırtıcı R '$ 0' tipi bir yapı yoktur! Bunu R ile yazılmış bir bash betiğine system () çağrısı ile yapabilirsiniz:

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

Sonra diğer için scriptpath.sh adını ayırın.

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

Çağrı yığınına baktığımızda, çalıştırılan her komut dosyasının dosya yolunu alabiliriz, en faydalı iki dosya muhtemelen şu anda yürütülen komut dosyası veya kaynaklanacak ilk komut dosyası (giriş) olacaktır.

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