Elixir 1.7

Path




elixir

Path

यह मॉड्यूल फ़ाइल सिस्टम पथों में हेरफेर या पुनर्प्राप्ति के लिए उपयुक्तता प्रदान करता है।

इस मॉड्यूल में कार्यों को तर्क के रूप में एक वर्णक प्राप्त हो सकता है (यानी एक स्ट्रिंग या वर्ण / स्ट्रिंग की एक सूची) और हमेशा एक स्ट्रिंग (UTF-8 में एन्कोडेड) वापस करेगा।

इस मॉड्यूल में अधिकांश फ़ंक्शन फ़ाइल सिस्टम के साथ इंटरैक्ट नहीं करते हैं, कुछ कार्यों को छोड़कर, जिनकी आवश्यकता होती है (जैसे wildcard/2 और expand/1 )।

सारांश

प्रकार

t()

कार्य

absname(path)

दिए गए मार्ग को पूर्णता में परिवर्तित करता है। expand/1 विपरीत, कोई समाधान करने का प्रयास नहीं किया जाता है .. , . या ~

absname (पथ, रिश्तेदार_तो)

पथिक relative_to लेकर path तक बनाता है

basename(path)

पथ के अंतिम घटक या पथ को स्वयं लौटाता है यदि इसमें कोई निर्देशिका विभाजक नहीं है

बेसन (पथ, विस्तार)

extension साथ path के अंतिम घटक को वापस कर देता है

dirname(path)

path के निर्देशिका घटक देता है

expand/1

मार्ग को पूर्णता में परिवर्तित करता है और किसी को भी विस्तारित करता है . और .. अक्षर और एक अग्रणी ~

विस्तार (पथ, रिश्तेदार_तो)

दूसरे तर्क के विस्तार के रूप में दिए गए पथ के सापेक्ष पथ का विस्तार करता है . और .. वर्ण

extname(path)

path के अंतिम घटक का विस्तार लौटाता है

join(list)

रास्तों की एक सूची में शामिल हो जाता है

शामिल होना (बाएं, दाएं)

दो रास्तों से जुड़ता है

relative(name)

एक सापेक्ष पथ होने के लिए मजबूर करता है

रिश्तेदार_तो (पथ, से)

दिए गए path सापेक्ष दिए गए path लौटाता है

relative_to_cwd(path)

वर्तमान कार्य निर्देशिका के सापेक्ष पथ प्राप्त करने की सुविधा

rootname(path)

extension वाले path को वापस कर देता है

रूटनाम (पथ, विस्तार)

extension वाले path को वापस कर देता है

split(path)

पथ विभाजक की सूची में पथ को विभाजित करता है

type(name)

पथ प्रकार लौटाता है

wildcard/2

ट्रैवर्सस दिए गए glob एक्सप्रेशन के अनुसार पथ glob है और मैचों की सूची देता है

प्रकार

टी ()

t() :: :unicode.chardata()

कार्य

absname (पथ)

absname(t()) :: binary()

दिए गए मार्ग को पूर्णता में परिवर्तित करता है। expand/1 विपरीत, कोई समाधान करने का प्रयास नहीं किया जाता है .. , . या ~

उदाहरण

यूनिक्स

Path.absname("foo")
#=> "/usr/local/foo"

Path.absname("../x")
#=> "/usr/local/../x"

विंडोज

Path.absname("foo").
#=> "D:/usr/local/foo"
Path.absname("../x").
#=> "D:/usr/local/../x"

absname (पथ, रिश्तेदार_तो)

absname(t(), t()) :: binary()

पथिक relative_to लेकर path तक बनाता है।

यदि path पहले से ही एक निरपेक्ष पथ है, तो relative_to अनदेखा कर दिया जाता है। relative_to/2 भी देखें

expand/2 विपरीत, कोई समाधान करने का प्रयास नहीं किया जाता है .. , . या ~

उदाहरण

iex> Path.absname("foo", "bar")
"bar/foo"

iex> Path.absname("../x", "bar")
"bar/../x"

basename (पथ)

basename(t()) :: binary()

पथ के अंतिम घटक या पथ को स्वयं लौटाता है यदि इसमें कोई निर्देशिका विभाजक नहीं है।

उदाहरण

iex> Path.basename("foo")
"foo"

iex> Path.basename("foo/bar")
"bar"

iex> Path.basename("/")
""

बेसन (पथ, विस्तार)

basename(t(), t()) :: binary()

extension साथ path के अंतिम घटक को वापस कर देता है।

इस फ़ंक्शन का उपयोग एक विशिष्ट एक्सटेंशन को हटाने के लिए किया जाना चाहिए जो कि हो सकता है या नहीं।

उदाहरण

iex> Path.basename("~/foo/bar.ex", ".ex")
"bar"

iex> Path.basename("~/foo/bar.exs", ".ex")
"bar.exs"

iex> Path.basename("~/foo/bar.old.ex", ".ex")
"bar.old"

dirname (पथ)

dirname(t()) :: binary()

path के निर्देशिका घटक देता है।

उदाहरण

iex> Path.dirname("/foo/bar.ex")
"/foo"

iex> Path.dirname("/foo/bar/baz.ex")
"/foo/bar"

iex> Path.dirname("/foo/bar/")
"/foo/bar"

विस्तार (पथ)

expand(t()) :: binary()

मार्ग को पूर्णता में परिवर्तित करता है और किसी को भी विस्तारित करता है . और .. अक्षर और एक अग्रणी ~

उदाहरण

Path.expand("/foo/bar/../bar")
#=> "/foo/bar"

विस्तार (पथ, रिश्तेदार_तो)

expand(t(), t()) :: binary()

दूसरे तर्क के विस्तार के रूप में दिए गए पथ के सापेक्ष पथ का विस्तार करता है . और .. वर्ण।

यदि पथ पहले से ही एक पूर्ण पथ है, तो relative_to अनदेखा कर दिया जाता है।

ध्यान दें कि यह फ़ंक्शन एक अग्रणी के साथ एक path इलाज करता है ~ एक पूर्ण के रूप में।

दूसरा तर्क सबसे पहले एक निरपेक्ष पथ पर विस्तारित होता है।

उदाहरण

# Assuming that the absolute path to baz is /quux/baz
Path.expand("foo/bar/../bar", "baz")
#=> "/quux/baz/foo/bar"

Path.expand("foo/bar/../bar", "/baz")
"/baz/foo/bar"
Path.expand("/foo/bar/../bar", "/baz")
"/foo/bar"

extname (पथ)

extname(t()) :: binary()

path के अंतिम घटक का विस्तार लौटाता है।

उदाहरण

iex> Path.extname("foo.erl")
".erl"

iex> Path.extname("~/foo/bar")
""

में शामिल होने के (सूची)

join([t(), ...]) :: binary()

रास्तों की एक सूची में शामिल हो जाता है।

इस फ़ंक्शन का उपयोग पथों की सूची को पथ में बदलने के लिए किया जाना चाहिए। ध्यान दें कि जुड़ने पर किसी भी ट्रेलिंग स्लैश को हटा दिया जाता है।

उदाहरण

iex> Path.join(["~", "foo"])
"~/foo"

iex> Path.join(["foo"])
"foo"

iex> Path.join(["/", "foo", "bar/"])
"/foo/bar"

शामिल होना (बाएं, दाएं)

join(t(), t()) :: binary()

दो रास्तों से जुड़ता है।

सही रास्ता हमेशा अपने सापेक्ष प्रारूप में विस्तारित किया जाएगा और जुड़ने पर किसी भी अनुगामी स्लैश को हटा दिया जाएगा।

उदाहरण

iex> Path.join("foo", "bar")
"foo/bar"

iex> Path.join("/foo", "/bar/")
"/foo/bar"

इस मॉड्यूल में कार्य चारधाता का समर्थन करते हैं, इसलिए एक सूची देने से इसे एकल इकाई माना जाएगा:

iex> Path.join("foo", ["bar", "fiz"])
"foo/barfiz"

iex> Path.join(["foo", "bar"], "fiz")
"foobar/fiz"

रिश्तेदार (नाम)

relative(t()) :: binary()

एक सापेक्ष पथ होने के लिए मजबूर करता है।

उदाहरण

यूनिक्स

Path.relative("/usr/local/bin")   #=> "usr/local/bin"
Path.relative("usr/local/bin")    #=> "usr/local/bin"
Path.relative("../usr/local/bin") #=> "../usr/local/bin"

विंडोज

Path.relative("D:/usr/local/bin") #=> "usr/local/bin"
Path.relative("usr/local/bin")    #=> "usr/local/bin"
Path.relative("D:bar.ex")         #=> "bar.ex"
Path.relative("/bar/foo.ex")      #=> "bar/foo.ex"

रिश्तेदार_तो (पथ, से)

relative_to(t(), t()) :: binary()

दिए गए path सापेक्ष दिए गए path लौटाता है।

दूसरे शब्दों में, यह फ़ंक्शन उपसर्ग से path from पट्टी करने का प्रयास करता है।

यह फ़ंक्शन फ़ाइल सिस्टम को क्वेरी नहीं करता है, इसलिए यह पथों के बीच कोई सहानुभूति नहीं मानता है।

यदि कोई सीधा रिश्तेदार पथ नहीं मिल सकता है, तो यह मूल पथ लौटाता है।

उदाहरण

iex> Path.relative_to("/usr/local/foo", "/usr/local")
"foo"

iex> Path.relative_to("/usr/local/foo", "/")
"usr/local/foo"

iex> Path.relative_to("/usr/local/foo", "/etc")
"/usr/local/foo"

relative_to_cwd (पथ)

relative_to_cwd(t()) :: binary()

वर्तमान कार्य निर्देशिका के सापेक्ष पथ प्राप्त करने की सुविधा।

यदि, किसी कारण से, वर्तमान कार्य निर्देशिका को पुनर्प्राप्त नहीं किया जा सकता है, तो यह फ़ंक्शन दिए गए path वापस करता path

rootname (पथ)

rootname(t()) :: binary()

extension वाले path को वापस कर देता है।

उदाहरण

iex> Path.rootname("/foo/bar")
"/foo/bar"

iex> Path.rootname("/foo/bar.ex")
"/foo/bar"

रूटनाम (पथ, विस्तार)

rootname(t(), t()) :: binary()

extension वाले path को वापस कर देता है।

इस फ़ंक्शन का उपयोग एक विशिष्ट एक्सटेंशन को हटाने के लिए किया जाना चाहिए जो कि हो सकता है या नहीं।

उदाहरण

iex> Path.rootname("/foo/bar.erl", ".erl")
"/foo/bar"

iex> Path.rootname("/foo/bar.erl", ".ex")
"/foo/bar.erl"

विभाजन (पथ)

split(t()) :: [binary()]

पथ विभाजक की सूची में पथ को विभाजित करता है।

यदि कोई खाली स्ट्रिंग दी जाती है, तो एक खाली सूची देता है।

विंडोज पर, पथ को "\" और "/" दोनों विभाजकों पर विभाजित किया जाता है और ड्राइवर अक्षर, यदि एक है, तो हमेशा लोअरकेस में वापस आ जाता है।

उदाहरण

iex> Path.split("")
[]

iex> Path.split("foo")
["foo"]

iex> Path.split("/foo/bar")
["/", "foo", "bar"]

नाम लिखो)

type(t()) :: :absolute | :relative | :volumerelative

पथ प्रकार लौटाता है।

उदाहरण

यूनिक्स

Path.type("/")                #=> :absolute
Path.type("/usr/local/bin")   #=> :absolute
Path.type("usr/local/bin")    #=> :relative
Path.type("../usr/local/bin") #=> :relative
Path.type("~/file")           #=> :relative

विंडोज

Path.type("D:/usr/local/bin") #=> :absolute
Path.type("usr/local/bin")    #=> :relative
Path.type("D:bar.ex")         #=> :volumerelative
Path.type("/bar/foo.ex")      #=> :volumerelative

वाइल्डकार्ड (ग्लोब, opts \\ [])

wildcard(t(), keyword()) :: [binary()]

ट्रैवर्सस दिए गए glob एक्सप्रेशन के अनुसार पथ glob है और मैचों की सूची देता है।

वाइल्डकार्ड एक सामान्य पथ की तरह दिखता है, सिवाय इसके कि "वाइल्डकार्ड वर्ण" की व्याख्या एक विशेष तरीके से की जाती है:

  • ? - एक वर्ण से मेल खाता है।

  • * - फ़ाइल नाम के अंत तक, अगले बिंदु या अगले स्लैश में किसी भी वर्ण से मेल खाता है।

  • ** - एक एकल पैटर्न के रूप में उपयोग किए जाने वाले दो आसन्न * सभी फाइलों और शून्य या अधिक निर्देशिकाओं और उपनिर्देशिकाओं से मेल खाएंगे।

  • [char1,char2,...] - सूचीबद्ध पात्रों में से किसी से मेल खाता है; एक हाइफ़न द्वारा अलग किए गए दो वर्ण कई वर्णों से मेल खाएंगे। अल्पविराम के पहले और बाद में रिक्त स्थान न जोड़ें क्योंकि यह अंतरिक्ष वर्ण से युक्त पथों से मेल खाएगा।

  • {item1,item2,...} - विकल्पों में से एक से मेल खाता है। अल्पविराम के पहले और बाद में रिक्त स्थान न जोड़ें क्योंकि यह अंतरिक्ष वर्ण से युक्त पथों से मेल खाएगा।

अन्य चरित्र खुद का प्रतिनिधित्व करते हैं। केवल पथ जो एक ही स्थिति में एक ही चरित्र हैं मेल खाते हैं। ध्यान दें कि मिलान केस-संवेदी है: "A" मेल नहीं खाएगा।

डिफ़ॉल्ट रूप से, पैटर्न * और ? डॉट के साथ शुरू होने वाली फ़ाइलों से मेल नहीं खाते . । नीचे दिए गए "विकल्प" अनुभाग में :match_dot विकल्प देखें।

विकल्प

  • :match_dot - (बूलियन) यदि false , विशेष वाइल्डकार्ड वर्ण * और ? एक डॉट ( . ) के साथ शुरू होने वाली फ़ाइलों से मेल नहीं खाएगा। यदि true , फाइलें a से शुरू होती हैं . विशेष रूप से इलाज नहीं किया जाएगा। false अवहेलना।

उदाहरण

कल्पना कीजिए कि आपके पास एक निर्देशिका है, ex_doc अंदर तीन अमृत परियोजनाओं वाली परियोजनाएँ हैं: elixir , ex_doc , और plug । आप निम्न के रूप में प्रत्येक परियोजना की ebin निर्देशिका के अंदर सभी .beam फाइलें पा सकते हैं:

Path.wildcard("projects/*/ebin/**/*.beam")

यदि आप .beam और .app दोनों फ़ाइलों की खोज करना चाहते हैं, तो आप कर सकते हैं:

Path.wildcard("projects/*/ebin/**/*.{beam,app}")