पथ को संयोजित करने के लिए फ़ंक्शन?

Question

क्या पथ को संयोजित करने के लिए कोई मौजूदा कार्य है?

मैं इसे जानता हूँ कि मैं उचित ओएस पथ प्रारूप का पता लगाने की देखभाल करने की आवश्यकता होगी अभी भी उस लागू करना मुश्किल है, लेकिन नहीं है ... / (या \) अनुगामी की देखभाल करने के अलावा (यानी हम लिख चाहे C:\dir\file या /dir/file) ।

जैसा कि मैंने कहा, मुझे विश्वास है कि मुझे पता है कि इसे कैसे कार्यान्वित किया जाए; सवाल यह है: क्या मुझे यह करना चाहिए? क्या मौजूदा आर पैकेज में कार्यक्षमता पहले से मौजूद है?

Answer 1

हाँ, file.path()

R> file.path("usr", "local", "lib") 
[1] "usr/local/lib" 
R> 

वहाँ भी एक पैकेज में फ़ाइलों के लिए समान रूप से उपयोगी system.path() है:

R> system.file("extdata", "date_time_zonespec.csv", package="RcppBDT") 
[1] "/usr/local/lib/R/site-library/RcppBDT/extdata/date_time_zonespec.csv" 
R> 

जो

1. जहां पर ध्यान दिए बिना फ़ाइल extdata/date_time_zonespec.csv मिल जाएगा पैकेज स्थापित है, और
2. ओएस

जो बहुत आसान है। अन्त में, वहाँ भी

R> .Platform$file.sep 
[1] "/" 
R> 

यदि आप इसे मैन्युअल रूप से कर रही पर जोर देते है।

Answer 2

यदि कोई चाहता है, तो यह मेरा स्वयं का फ़ंक्शन path.cat है। इसकी कार्यक्षमता अतिरिक्त चीनी के साथ पाइथन के os.path.join के साथ तुलनीय है, यह .. का अर्थ है।

इस फ़ंक्शन के साथ, आप पदानुक्रमित पथ बना सकते हैं, लेकिन file.path के विपरीत, आप उपयोगकर्ता को पूर्ण पथ डालकर पदानुक्रम को ओवरराइड करने की क्षमता छोड़ देते हैं। और एक अतिरिक्त चीनी के रूप में, वह स्पष्ट अर्थ के साथ ".." जहां भी वह पथ में पसंद करता है डाल सकता है।

उदा।

• path.cat("/home/user1","project/data","../data2") yelds /home/user1/project/data2

• path.cat("/home/user1","project/data","/home/user2/data") yelds /home/user2/data

समारोह केवल पथ विभाजक है, जो ठीक है, के बाद से आर पारदर्शी रूप से Windows मशीन पर बैकस्लैश करने के लिए उन्हें तब्दील हो के रूप में स्लैश के साथ काम करता है।

library("iterators") # After writing this function I've learned, that iterators are very inefficient in R. 
library("itertools") 

#High-level function that inteligentely concatenates paths given in arguments 
#The user interface is the same as for file.path, with the exception that it understands the path ".." 
#and it can identify relative and absolute paths. 
#Absolute paths starts comply with "^\/" or "^\d:\/" regexp. 
#The concatenation starts from the last absolute path in arguments, or the first, if no absolute paths are given. 
path.cat<-function(...) 
{ 
    elems<-list(...) 
    elems<-as.character(elems) 
    elems<-elems[elems!='' && !is.null(elems)] 
    relems<-rev(elems) 
    starts<-grep('^[/\\]',relems)[1] 
    if (!is.na(starts) && !is.null(starts)) 
    { 
    relems<-relems[1:starts] 
    } 
    starts<-grep(':',relems,fixed=TRUE) 
    if (length(starts)==0){ 
    starts=length(elems)-length(relems)+1 
    }else{ 
    starts=length(elems)-starts[[1]]+1} 
    elems<-elems[starts:length(elems)] 
    path<-do.call(file.path,as.list(elems)) 
    elems<-strsplit(path,'[/\\]',FALSE)[[1]] 
    it<-ihasNext(iter(elems)) 
    out<-rep(NA,length(elems)) 
    i<-1 
    while(hasNext(it)) 
    { 
    item<-nextElem(it) 
    if(item=='..') 
    { 
     i<-i-1 
    } else if (item=='' & i!=1) { 
     #nothing 
    } else { 
     out[i]<-item 
     i<-i+1 
    } 
    } 
    do.call(file.path,as.list(out[1:i-1])) 
}