Elixir 1.7

File




elixir

File

इस मॉड्यूल में फ़ाइलों में हेरफेर करने के लिए कार्य शामिल हैं।

उन कार्यों में से कुछ निम्न-स्तर हैं, जिससे उपयोगकर्ता फ़ाइलों या IO उपकरणों के साथ बातचीत कर सकते हैं, जैसे कि open/2 , copy/3 और अन्य। यह मॉड्यूल उच्च स्तर के कार्य भी प्रदान करता है जो फ़ाइल नाम के साथ काम करते हैं और UNIX वेरिएंट के आधार पर उनका नामकरण होता है। उदाहरण के लिए, कोई cp/3 माध्यम से किसी फ़ाइल को कॉपी कर सकता है और rm_rf/1 माध्यम से फ़ाइलों और निर्देशिकाओं को पुन: हटा सकता है।

इस मॉड्यूल में फ़ंक्शंस के लिए दिए गए रास्ते या तो वर्तमान वर्किंग डायरेक्टरी के सापेक्ष हो सकते हैं (जैसा कि File.cwd/0 द्वारा लौटाया गया है), या निरपेक्ष File.cwd/0 । शेल कन्वेंशन जैसे ~ स्वचालित रूप से विस्तारित नहीं होते हैं। ~/Downloads जैसे रास्तों का उपयोग करने के लिए, आप अपने पथ को निरपेक्ष पथ पर विस्तारित करने के लिए Path.expand/1 या Path.expand/2 का उपयोग कर सकते हैं।

एन्कोडिंग

फ़ाइलों को लिखने और पढ़ने के लिए, किसी को IO मॉड्यूल में फ़ंक्शन का उपयोग करना चाहिए। डिफ़ॉल्ट रूप से, एक फाइल बाइनरी मोड में खोली जाती है, जिसमें फ़ाइल के साथ इंटरैक्ट करने के लिए IO.binread/2 और IO.binwrite/2 आवश्यकता होती है। एक डेवलपर पास कर सकता है :utf8 फ़ाइल खोलते समय एक विकल्प के रूप में :utf8 , फिर धीमी IO.write/2 और IO.write/2 फ़ंक्शन का उपयोग किया जाना चाहिए क्योंकि वे उचित रूपांतरण करने और उचित डेटा गारंटी प्रदान करने के लिए जिम्मेदार हैं।

ध्यान दें कि जब अमृत में चार्लिस्ट के रूप में दिया जाता है तो फाइलनाम हमेशा यूटीएफ -8 के रूप में माना जाता है। विशेष रूप से, हम उम्मीद करते हैं कि शेल और ऑपरेटिंग सिस्टम को UTF-8 एन्कोडिंग का उपयोग करने के लिए कॉन्फ़िगर किया गया है। बाइनरी फाइलनाम को कच्चा माना जाता है और जैसा कि ओएस को दिया जाता है।

एपीआई

इस मॉड्यूल रिटर्न में अधिकांश कार्य :ok या {:ok, result} सफलता के मामले में, {:error, reason} अन्यथा। उन फ़ंक्शंस में एक वेरिएंट भी होता है, जो समाप्त होता है ! जो सफलता के मामले में परिणाम ( {:ok, result} tuple के बजाय) लौटाता है या असफल होने की स्थिति में अपवाद को जन्म देता है। उदाहरण के लिए:

File.read("hello.txt")
#=> {:ok, "World"}

File.read("invalid.txt")
#=> {:error, :enoent}

File.read!("hello.txt")
#=> "World"

File.read!("invalid.txt")
#=> raises File.Error

सामान्य तौर पर, एक डेवलपर को उस मामले में पूर्व का उपयोग करना चाहिए, जब फ़ाइल मौजूद नहीं है तो वे प्रतिक्रिया करना चाहते हैं। बाद में इस्तेमाल किया जाना चाहिए, जब डेवलपर को अपने सॉफ़्टवेयर के विफल होने की उम्मीद है, तो फ़ाइल को पढ़ा नहीं जा सकता है (यानी यह सचमुच एक अपवाद है)।

प्रक्रियाएं और कच्ची फाइलें

हर बार एक फ़ाइल खोले जाने पर, अमृत एक नई प्रक्रिया पैदा करता है। किसी फ़ाइल में लिखना उस प्रक्रिया को संदेश भेजने के बराबर है जो फ़ाइल डिस्क्रिप्टर को लिखता है।

इसका मतलब यह है कि फाइलें नोड्स और संदेश पासिंग गारंटी के बीच पारित की जा सकती हैं जो वे एक नेटवर्क में एक ही फाइल पर लिख सकते हैं।

हालांकि, आप हमेशा इस अमूर्त के लिए कीमत का भुगतान नहीं करना चाह सकते हैं। ऐसे मामलों में, एक फ़ाइल को :raw मोड में खोला जा सकता है। विकल्प :read_ahead और :delayed_write बड़ी फ़ाइलों पर काम करते समय या तंग छोरों में फ़ाइलों के साथ काम करते समय भी उपयोगी होते हैं।

ऐसे विकल्पों और अन्य प्रदर्शन विचारों के बारे में अधिक जानकारी के लिए जाँच करें :file.open/2

सारांश

प्रकार

encoding_mode()
io_device()
mode()
posix()
stat_options()
stream_mode()

कार्य

cd!(path)

cd/1 समान, लेकिन यदि यह विफल रहता है तो एक अपवाद उठाता है

सीडी (पथ, फ़ंक्शन)

वर्तमान निर्देशिका को दिए गए path परिवर्तन करता है, दिए गए फ़ंक्शन को निष्पादित करता है और फिर पिछले मार्ग पर वापस लौट जाता है, भले ही कोई अपवाद न हो

cd/1

वर्तमान कार्य निर्देशिका सेट करता है

chgrp। (पथ, gid)

chgrp/2 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

chgrp/2

समूह आईडी द्वारा दिए गए समूह को किसी दिए गए file । रिटर्न :ok सफलता पर :ok है, या {:error, reason} विफलता पर

chmod! (पथ, मोड)

chmod/2 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

chmod/2

किसी दिए गए file लिए mode को बदलता है

chown! (पथ, uid)

chown/2 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

chown/2

किसी दिए गए file लिए उपयोगकर्ता आईडी द्वारा दिए गए स्वामी को बदलता है। रिटर्न :ok सफलता पर :ok है, या {:error, reason} विफलता पर

close(io_device)

io_device द्वारा संदर्भित फ़ाइल को बंद कर io_device । यह ज्यादातर लौटता है :ok , कुछ गंभीर त्रुटियों को छोड़कर जैसे कि मेमोरी से बाहर

कॉपी (स्रोत, गंतव्य, बाइट्स_काउंट \\: इन्फिनिटी)

copy/3 की तरह ही, लेकिन अगर यह विफल रहता है तो एक File.CopyError बढ़ाता है। अन्यथा bytes_copied वापस लौटाता है

copy/3

destination लिए source की सामग्री की प्रतिलिपि destination

cp! (स्रोत, गंतव्य, कॉलबैक \\ fn _, _ -> सत्य अंत)

File.CopyError cp/3 समान है, लेकिन यदि यह विफल हो जाता है तो File.CopyError बढ़ाता है। रिटर्न :ok अन्यथा

cp/3

source में सामग्री को कॉपी करके अपने मोड को संरक्षित रखने के लिए

cp_r! (स्रोत, गंतव्य, कॉलबैक \\ fn _, _ -> सत्य अंत)

cp_r/3 समान, लेकिन यदि यह विफल हो जाता है तो File.CopyError उठाता है। अन्यथा कॉपी की गई फ़ाइलों की सूची लौटाता है

cp_r/3

गंतव्य के लिए स्रोत में सामग्री की प्रतिलिपि बनाता है

cwd!()

cwd/0 समान, लेकिन यह विफल होने पर एक अपवाद को बढ़ाता है

cwd/0

वर्तमान कार्य निर्देशिका प्राप्त करता है

dir?(path)

यदि दिया गया मार्ग निर्देशिका है तो true है

exists?(path)

यदि दिया गया पथ मौजूद true तो true है

ln! (मौजूदा, नया)

ln/2 समान है लेकिन यदि यह विफल रहता है तो एक अपवाद को बढ़ाता है

ln/2

existing फ़ाइल के लिए एक हार्ड लिंक new बनाता है

ln_s! (मौजूदा, नया)

ln_s/2 रूप में भी समान है लेकिन अगर यह विफल रहता है तो एक अपवाद उठाता है

ln_s/2

existing फ़ाइल या निर्देशिका के लिए एक प्रतीकात्मक लिंक new बनाता है

ls! (पथ \\ "")

ls/1 जैसा ही, लेकिन एक त्रुटि के मामले में File.Error को बढ़ाता है

ls/1

दी गई डायरेक्टरी में फाइलों की सूची लौटाता है

lstat! (पथ, opts \\ [])

lstat/2 रूप में समान है, लेकिन File.Stat वापस लौटाता है। सीधे संरचना को File.Stat , या File.Error फेंकता है। त्रुटि होने पर वापस आ जाता है

lstat/2

path बारे में जानकारी देता है। यदि फ़ाइल एक सिमलिंक है, तो type करें :symlink File.Stat और लिंक के लिए File.Stat संरचना लौटाता है। किसी भी अन्य फ़ाइल के लिए, बिल्कुल वैसा ही मान है जैसा stat/2

mkdir!(path)

mkdir/1 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

mkdir/1

निर्देशिका path बनाने की कोशिश करता path

mkdir_p!(path)

mkdir_p/1 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

mkdir_p/1

निर्देशिका path बनाने की कोशिश करता path

खुला है (पथ, मोड_or_function \\ [])

open/2 लिए समान open/2 लेकिन एक त्रुटि उठाता है यदि फ़ाइल नहीं खोली जा सकती

खुला (पथ, मोड, फ़ंक्शन)

open/3 लिए समान open/3 लेकिन एक त्रुटि उठाता है अगर फ़ाइल नहीं खोली जा सकती

open/2

दिए गए path खोलता है

open/3

open/2 समान लेकिन किसी फ़ंक्शन को उसके अंतिम तर्क के रूप में अपेक्षित करता है

read!(path)

दिए गए फ़ाइल नाम की सामग्री के साथ एक द्विआधारी लौटाता है या यदि कोई त्रुटि होती है तो फ़ाइल को उठाता है

read(path)

रिटर्न {:ok, binary} , जहां binary एक बाइनरी डेटा ऑब्जेक्ट है जिसमें path की सामग्री होती path , या {:error, reason} यदि कोई त्रुटि होती है

read_link!(path)

read_link/1 रूप में समान है, लेकिन सीधे लक्ष्य देता है या यदि कोई त्रुटि वापस File.Error तो File.Error फेंकता है

read_link/1

path पर प्रतीकात्मक लिंक पढ़ता है

regular?(path)

यदि पथ एक नियमित फ़ाइल है, तो true है

नाम बदलें (स्रोत, गंतव्य)

destination फ़ाइल के लिए source फ़ाइल का नाम बदलता है। इसका उपयोग निर्देशिकाओं के बीच फ़ाइलों (और निर्देशिकाओं) को स्थानांतरित करने के लिए किया जा सकता है। यदि कोई फ़ाइल चलती है, तो आपको destination फ़ाइल नाम को पूरी तरह से निर्दिष्ट करना होगा, यह केवल इसकी निर्देशिका निर्दिष्ट करने के लिए पर्याप्त नहीं है

rm!(path)

rm/1 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

rm/1

फ़ाइल path को हटाने का प्रयास करता path

rm_rf!(path)

rm_rf/1 रूप में समान है, लेकिन विफलताओं के मामले में File.Error को बढ़ाता है, अन्यथा फ़ाइलों या निर्देशिकाओं की सूची हटा दी जाती है

rm_rf/1

फ़ाइलों और निर्देशिकाओं को दिए गए path पर पुन: हटाता path । साइमलिंक का पालन नहीं किया जाता है लेकिन बस हटा दिया जाता है, गैर-मौजूदा फ़ाइलों को केवल अनदेखा कर दिया जाता है (अर्थात यह फ़ंक्शन विफल नहीं होता है)

rmdir!(path)

rmdir/1 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

rmdir/1

path में डायर को हटाने की कोशिश करता path

स्टेट! (पथ, opts \\ [])

stat/2 रूप में समान है, लेकिन File.Stat वापस लौटाता है। सीधे File.Stat करें, या File.Error फेंकता है File.Error यदि कोई त्रुटि वापस File.Error तो

stat/2

path बारे में जानकारी देता है। यदि यह मौजूद है, तो यह एक {:ok, info} tuple देता है, जहां जानकारी एक File.Stat संरचना है। रिटर्न {:error, reason} उसी कारणों के साथ जैसे read(path) यदि फेल होता है

स्ट्रीम (पथ, मोड \\ [], line_or_bytes \\: लाइन)

दिए गए modes साथ दिए गए path लिए एक File.Stream लौटाता है

स्पर्श करें (पथ, समय \\: Calendar.universal_time ())

touch/2 रूप में भी, लेकिन अगर यह विफल रहता है तो एक अपवाद उठाता है

touch/2

अपडेट किए गए संशोधन समय (माइम) और दिए गए फ़ाइल का एक्सेस समय (Atime)

लिखें (पथ, सामग्री, मोड \\ [])

write/3 रूप में भी write/3 लेकिन अगर यह विफल रहता है तो एक अपवाद उठाता है, रिटर्न :ok अन्यथा

write/3

फ़ाइल path content लिखता content

write_stat! (पथ, स्टेट, opts \\ [])

write_stat/3 समान लेकिन यदि यह विफल रहता है तो एक अपवाद उठाता है। रिटर्न :ok अन्यथा

write_stat/3

दिए गए फ़ाइल को लिखता है। दिए गए पथ पर फ़ाइल सिस्टम पर वापस जाएं। रिटर्न :ok या {:error, reason}

प्रकार

encoding_mode ()

encoding_mode() ::
  :utf8
  | {:encoding,
     :latin1
     | :unicode
     | :utf8
     | :utf16
     | :utf32
     | {:utf16, :big | :little}
     | {:utf32, :big | :little}}

io_device ()

io_device() :: :file.io_device()

मोड ()

mode() ::
  :append
  | :binary
  | :charlist
  | :compressed
  | :delayed_write
  | :exclusive
  | :raw
  | :read
  | :read_ahead
  | :sync
  | :write
  | {:read_ahead, pos_integer()}
  | {:delayed_write, non_neg_integer(), non_neg_integer()}
  | encoding_mode()

POSIX ()

posix() :: :file.posix()

stat_options ()

stat_options() :: [{:time, :local | :universal | :posix}]

stream_mode ()

stream_mode() ::
  encoding_mode()
  | :trim_bom
  | {:read_ahead, pos_integer() | false}
  | {:delayed_write, non_neg_integer(), non_neg_integer()}

कार्य

सीडी! (पथ)

cd!(Path.t()) :: :ok | no_return()

cd/1 समान, लेकिन यदि यह विफल रहता है तो एक अपवाद उठाता है।

सीडी (पथ, फ़ंक्शन)

cd!(Path.t(), (() -> res)) :: res when res: var

वर्तमान निर्देशिका को दिए गए path परिवर्तन करता है, दिए गए फ़ंक्शन को निष्पादित करता है और फिर पिछले मार्ग पर वापस लौट जाता है, भले ही कोई अपवाद न हो।

वर्तमान निर्देशिका को पुनर्प्राप्त या परिवर्तित करने में कोई त्रुटि उठाता है तो विफल हो जाता है।

सीडी (पथ)

cd(Path.t()) :: :ok | {:error, posix()}

वर्तमान कार्य निर्देशिका सेट करता है।

रिटर्न :ok अगर सफल, {:error, reason} अन्यथा।

chgrp। (पथ, gid)

chgrp!(Path.t(), non_neg_integer()) :: :ok | no_return()

chgrp/2 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

chgrp (पथ, gid)

chgrp(Path.t(), non_neg_integer()) :: :ok | {:error, posix()}

समूह आईडी द्वारा दिए गए समूह को किसी दिए गए file । रिटर्न :ok सफलता पर :ok है, या {:error, reason} विफलता पर।

chmod! (पथ, मोड)

chmod!(Path.t(), non_neg_integer()) :: :ok | no_return()

chmod/2 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

chmod (पथ, मोड)

chmod(Path.t(), non_neg_integer()) :: :ok | {:error, posix()}

किसी दिए गए file लिए mode को बदलता है।

रिटर्न :ok सफलता पर :ok है, या {:error, reason} विफलता पर।

अनुमतियां

फ़ाइल की अनुमति निम्नलिखित अष्टक झंडों को एक साथ जोड़कर दी गई है:

  • 0o400 - पढ़ने की अनुमति: मालिक

  • 0o200 - अनुमति लिखें: मालिक

  • 0o100 - निष्पादित अनुमति: मालिक

  • 0o040 - पढ़ने की अनुमति: समूह

  • 0o020 - लेखन अनुमति: समूह

  • 0o010 - निष्पादन की अनुमति: समूह

  • 0o004 - पढ़ने की अनुमति: अन्य

  • 0o002 - अनुमति लिखें: अन्य

  • 0o001 - निष्पादित अनुमति: अन्य

उदाहरण के लिए, मोड 0o755 को सेट करने से यह मालिक को लिखने, पढ़ने और निष्पादित करने की अनुमति देता है और समूह और अन्य के लिए दोनों पढ़ने और निष्पादित करने की अनुमति देता है।

chown! (पथ, uid)

chown!(Path.t(), non_neg_integer()) :: :ok | no_return()

chown/2 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

चाउन (पथ, यूआईडी)

chown(Path.t(), non_neg_integer()) :: :ok | {:error, posix()}

किसी दिए गए file लिए उपयोगकर्ता आईडी द्वारा दिए गए स्वामी को बदलता है। रिटर्न :ok सफलता पर :ok है, या {:error, reason} विफलता पर।

करीब (io_device)

close(io_device()) :: :ok | {:error, posix() | :badarg | :terminated}

io_device द्वारा संदर्भित फ़ाइल को बंद कर io_device । यह ज्यादातर लौटता है :ok , कुछ गंभीर त्रुटियों को छोड़कर जैसे कि मेमोरी से बाहर।

ध्यान दें कि यदि विकल्प :delayed_write फाइल खोलने के दौरान :delayed_write का उपयोग किया गया था, तो close(io_device) एक पुरानी लेखन त्रुटि लौटा सकता है और फ़ाइल को बंद करने का प्रयास भी नहीं कर सकता है। अधिक जानकारी के लिए open/2 देखें।

कॉपी (स्रोत, गंतव्य, बाइट्स_काउंट \\: इन्फिनिटी)

copy!(Path.t() | io_device(), Path.t() | io_device(), pos_integer() | :infinity) ::
  non_neg_integer() | no_return()

copy/3 की तरह ही, लेकिन अगर यह विफल रहता है तो एक File.CopyError बढ़ाता है। अन्यथा bytes_copied वापस लौटाता है।

कॉपी (स्रोत, गंतव्य, बाइट्स_काउंट \\: इन्फिनिटी)

copy(Path.t() | io_device(), Path.t() | io_device(), pos_integer() | :infinity) ::
  {:ok, non_neg_integer()} | {:error, posix()}

destination लिए source की सामग्री की प्रतिलिपि destination

दोनों पैरामीटर एक फ़ाइल नाम या एक IO डिवाइस हो सकते हैं जिसे open/2 साथ खोला गया है। bytes_count कॉपी करने के लिए बाइट्स की संख्या निर्दिष्ट करता है, डिफ़ॉल्ट :infinity

यदि फ़ाइल destination पहले से मौजूद है, तो यह source में सामग्री द्वारा अधिलेखित है।

रिटर्न {:ok, bytes_copied} यदि सफल हो, {:error, reason} अन्यथा।

cp/3 तुलना में, यह फ़ंक्शन अधिक निम्न-स्तर है, जो डिवाइस से डिवाइस को कॉपी करके कई बाइट्स तक सीमित करता है। दूसरी ओर, cp/3 स्रोत और गंतव्य दोनों पर अधिक व्यापक जाँच करता है और यह प्रतिलिपि के बाद फ़ाइल मोड को भी संरक्षित करता है।

विशिष्ट त्रुटि कारण open/2 , read(path) और write/3

cp! (स्रोत, गंतव्य, कॉलबैक \\ fn _, _ -> सत्य अंत)

cp!(Path.t(), Path.t(), (Path.t(), Path.t() -> boolean())) :: :ok | no_return()

File.CopyError cp/3 समान है, लेकिन यदि यह विफल हो जाता है तो File.CopyError बढ़ाता है। रिटर्न :ok अन्यथा।

cp (स्रोत, गंतव्य, कॉलबैक \\ fn _, _ -> सत्य अंत)

cp(Path.t(), Path.t(), (Path.t(), Path.t() -> boolean())) ::
  :ok | {:error, posix()}

source में सामग्री को कॉपी करके अपने मोड को संरक्षित रखने के लिए।

यदि कोई फ़ाइल गंतव्य में पहले से मौजूद है, तो यह एक कॉलबैक को आमंत्रित करता है जो कि true होना चाहिए अगर मौजूदा फ़ाइल को अधिलेखित किया जाना चाहिए, अन्यथा false । कॉलबैक true लौटने के लिए डिफॉल्ट करता true

फ़ंक्शन रिटर्न करता है :ok सफलता के मामले में :ok है, रिटर्न {:error, reason} अन्यथा।

यदि आप IO डिवाइस से किसी अन्य डिवाइस पर सामग्री की प्रतिलिपि बनाना चाहते हैं या किसी स्रोत से गंतव्य तक बिना मोड्स को संरक्षित किए सीधे कॉपी कर सकते हैं, तो इसके बजाय copy/3 जांच करें।

नोट: यूनिक्स सिस्टम में कमांड cp अलग-अलग तरीके से व्यवहार करता है, क्योंकि destination एक मौजूदा निर्देशिका है या नहीं। हमने इस व्यवहार को स्पष्ट रूप से अस्वीकार करने के लिए चुना है। यदि गंतव्य एक निर्देशिका है, तो एक त्रुटि वापस आ जाएगी।

cp_r! (स्रोत, गंतव्य, कॉलबैक \\ fn _, _ -> सत्य अंत)

cp_r!(Path.t(), Path.t(), (Path.t(), Path.t() -> boolean())) ::
  [binary()] | no_return()

cp_r/3 समान, लेकिन यदि यह विफल हो जाता है तो File.CopyError उठाता है। अन्यथा कॉपी की गई फ़ाइलों की सूची लौटाता है।

cp_r (स्रोत, गंतव्य, कॉलबैक \\ fn _, _ -> - सच्चा अंत)

cp_r(Path.t(), Path.t(), (Path.t(), Path.t() -> boolean())) ::
  {:ok, [binary()]} | {:error, posix(), binary()}

गंतव्य के लिए स्रोत में सामग्री की प्रतिलिपि बनाता है।

यदि स्रोत एक फ़ाइल है, तो यह source को destination कॉपी करता destination । यदि स्रोत एक निर्देशिका है, तो यह स्रोत के अंदर की सामग्री को गंतव्य में कॉपी करता है।

यदि कोई फ़ाइल गंतव्य में पहले से मौजूद है, तो यह callback आमंत्रित करता है। callback एक फ़ंक्शन होना चाहिए जो दो तर्क लेता है: source और destination । कॉलबैक true होना चाहिए अगर मौजूदा फ़ाइल को अधिलेखित और false होना चाहिए।

यदि कोई निर्देशिका पहले से मौजूद है जहाँ फ़ाइल किसी फ़ाइल के लिए है (या इसके विपरीत), तो यह फ़ंक्शन विफल हो जाएगा।

फ़ाइलों को कॉपी करते समय यह फ़ंक्शन विफल हो सकता है, ऐसे मामलों में, यह गंतव्य निर्देशिका को एक गंदे स्थिति में छोड़ देगा, जहां पहले से कॉपी की गई फ़ाइल को हटाया नहीं जाएगा।

सफलता के मामले में फ़ंक्शन रिटर्न {:ok, files_and_directories} , files_and_directories सभी फ़ाइलों और निर्देशिकाओं को बिना किसी विशिष्ट क्रम में कॉपी किए सूचीबद्ध करता है। यह {:error, reason, file} अन्यथा।

नोट: यूनिक्स सिस्टम में कमांड cp अलग-अलग तरीके से व्यवहार करता है, क्योंकि destination एक मौजूदा निर्देशिका है या नहीं। हमने इस व्यवहार को स्पष्ट रूप से अस्वीकार करने के लिए चुना है।

उदाहरण

# Copies file "a.txt" to "b.txt"
File.cp_r "a.txt", "b.txt"

# Copies all files in "samples" to "tmp"
File.cp_r "samples", "tmp"

# Same as before, but asks the user how to proceed in case of conflicts
File.cp_r "samples", "tmp", fn source, destination ->
  IO.gets("Overwriting #{destination} by #{source}. Type y to confirm. ") == "y\n"
end

CWD! ()

cwd!() :: binary() | no_return()

cwd/0 समान, लेकिन यह विफल होने पर एक अपवाद को बढ़ाता है।

CWD ()

cwd() :: {:ok, binary()} | {:error, posix()}

वर्तमान कार्य निर्देशिका प्राप्त करता है।

दुर्लभ परिस्थितियों में, यह फ़ंक्शन यूनिक्स पर विफल हो सकता है। यह तब हो सकता है जब पठन अनुमतियाँ वर्तमान निर्देशिका के मूल निर्देशिका के लिए मौजूद न हों। इस कारण से, सफलता के मामले में {:ok, cwd} , {:error, reason} अन्यथा।

dir? (पथ)

dir?(Path.t()) :: boolean()

यदि दिया गया मार्ग निर्देशिका है तो true है।

यह फ़ंक्शन प्रतीकात्मक लिंक का अनुसरण करता है, इसलिए यदि कोई प्रतीकात्मक लिंक किसी निर्देशिका को इंगित करता है, तो true वापस आ जाता है।

उदाहरण

File.dir?("./test")
#=> true

File.dir?("test")
#=> true

File.dir?("/usr/bin")
#=> true

File.dir?("~/Downloads")
#=> false

"~/Downloads" |> Path.expand |> File.dir?
#=> true

मौजूद है? (पथ)

exists?(Path.t()) :: boolean()

यदि दिया गया पथ मौजूद true तो true है।

यह नियमित रूप से फ़ाइल, निर्देशिका, सॉकेट, प्रतीकात्मक लिंक, नामित पाइप या डिवाइस फ़ाइल हो सकती है। गैर-मौजूदा लक्ष्यों की ओर इशारा करते हुए प्रतीकात्मक लिंक के लिए false

उदाहरण

File.exists?("test/")
#=> true

File.exists?("missing.txt")
#=> false

File.exists?("/dev/null")
#=> true

ln! (मौजूदा, नया) (1.5.0 से)

ln!(Path.t(), Path.t()) :: :ok | no_return()

ln/2 समान है लेकिन यदि यह विफल रहता है तो एक अपवाद को बढ़ाता है।

रिटर्न :ok अन्यथा

ln (मौजूदा, नया) (1.5.0 से)

ln(Path.t(), Path.t()) :: :ok | {:error, posix()}

existing फ़ाइल के लिए एक हार्ड लिंक new बनाता है।

रिटर्न :ok अगर सफल, {:error, reason} अन्यथा। यदि ऑपरेटिंग सिस्टम हार्ड लिंक का समर्थन नहीं करता है, तो रिटर्न {:error, :enotsup}

ln_s! (मौजूदा, नया)

ln_s!(Path.t(), Path.t()) :: :ok | no_return()

ln_s/2 रूप में भी समान है लेकिन अगर यह विफल रहता है तो एक अपवाद उठाता है।

रिटर्न :ok अन्यथा

ln_s (मौजूदा, नया) (1.5.0 से)

ln_s(Path.t(), Path.t()) :: :ok | {:error, posix()}

existing फ़ाइल या निर्देशिका के लिए एक प्रतीकात्मक लिंक new बनाता है।

रिटर्न :ok अगर सफल, {:error, reason} अन्यथा। यदि ऑपरेटिंग सिस्टम {:error, :enotsup} समर्थन नहीं करता है, तो रिटर्न {:error, :enotsup}

ls! (पथ \\ "")

ls!(Path.t()) :: [binary()] | no_return()

ls/1 जैसा ही, लेकिन एक त्रुटि के मामले में File.Error को बढ़ाता है।

ls (पथ \\ ")"

ls(Path.t()) :: {:ok, [binary()]} | {:error, posix()}

दी गई डायरेक्टरी में फाइलों की सूची लौटाता है।

सफलता के मामले में {:ok, files} को लौटाता है, {:error, reason} अन्यथा।

lstat! (पथ, opts \\ [])

lstat!(Path.t(), stat_options()) :: File.Stat.t() | no_return()

lstat/2 रूप में समान है, लेकिन सीधे File.Stat संरचना लौटाता है, या यदि कोई त्रुटि वापस File.Error तो File.Error फेंकता है।

lstat (पथ, opts \\ [])

lstat(Path.t(), stat_options()) :: {:ok, File.Stat.t()} | {:error, posix()}

path बारे में जानकारी देता है। यदि फ़ाइल एक सिमलिंक है, तो type करें :symlink File.Stat और लिंक के लिए File.Stat संरचना लौटाता है। किसी भी अन्य फ़ाइल के लिए, बिल्कुल वैसा ही मान है जैसा stat/2

अधिक जानकारी के लिए, देखें :file.read_link_info/2

विकल्प

स्वीकृत विकल्प हैं:

  • :time - कॉन्फ़िगर करता है कि फ़ाइल टाइमस्टैम्प कैसे लौटाए जाते हैं

इसके लिए मान हो सकते हैं :time :

  • :universal - यूटीसी (डिफ़ॉल्ट) में एक {date, time} टपल लौटाता है
  • :local - मशीन समय का उपयोग करके एक {date, time} टपल लौटाता है
  • :posix - युग के बाद से पूर्णांक सेकंड के रूप में समय देता है

mkdir! (पथ)

mkdir!(Path.t()) :: :ok | no_return()

mkdir/1 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

mkdir (पथ)

mkdir(Path.t()) :: :ok | {:error, posix()}

निर्देशिका path बनाने की कोशिश करता path

अनुपलब्ध मूल निर्देशिका नहीं बनाई गई हैं। रिटर्न :ok अगर सफल, या {:error, reason} यदि कोई त्रुटि होती है।

विशिष्ट त्रुटि कारण हैं:

  • :eacces - लापता खोज या path के मूल निर्देशिका के लिए अनुमति लिखना
  • :eexist - पहले से ही एक फ़ाइल या निर्देशिका नाम path
  • :enoent - path का एक घटक मौजूद नहीं है
  • :enospc - डिवाइस पर कोई जगह नहीं बची है
  • :enotdir - path का एक घटक निर्देशिका नहीं है; कुछ प्लेटफार्मों पर :enoent को इसके बदले लौटाया जाता है

mkdir_p! (पथ)

mkdir_p!(Path.t()) :: :ok | no_return()

mkdir_p/1 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

mkdir_p (पथ)

mkdir_p(Path.t()) :: :ok | {:error, posix()}

निर्देशिका path बनाने की कोशिश करता path

गुम पेरेंट निर्देशिका बनाई जाती हैं। रिटर्न :ok अगर सफल, या {:error, reason} यदि कोई त्रुटि होती है।

विशिष्ट त्रुटि कारण हैं:

  • :eacces - लापता खोज या path के मूल निर्देशिका के लिए अनुमति लिखना
  • :enospc - डिवाइस पर कोई जगह नहीं बची है
  • :enotdir - path का एक घटक निर्देशिका नहीं है

खुला है (पथ, मोड_or_function \\ [])

open!(Path.t(), (io_device() -> res)) :: res | no_return() when res: var
open!(Path.t(), [mode() | :ram]) :: io_device() | no_return()

open/2 लिए समान open/2 लेकिन एक त्रुटि उठाता है यदि फ़ाइल नहीं खोली जा सकती।

अन्यथा IO डिवाइस लौटाता है।

उपलब्ध मोड की सूची के लिए open/2 देखें।

खुला (पथ, मोड, फ़ंक्शन)

open!(Path.t(), [mode() | :ram], (io_device() -> res)) :: res | no_return()
when res: var

open/3 लिए समान open/3 लेकिन एक त्रुटि उठाता है अगर फ़ाइल नहीं खोली जा सकती।

यदि यह फ़ाइल खोलने में सफल होता है, तो यह IO डिवाइस पर function परिणाम देता है।

उपलब्ध modes की सूची के लिए open/2 देखें।

खुला (पथ, मोड_or_function \\ [])

open(Path.t(), (io_device() -> res)) :: {:ok, res} | {:error, posix()}
when res: var
open(Path.t(), [mode() | :ram]) :: {:ok, io_device()} | {:error, posix()}

दिए गए path खोलता है।

फ़ाइलों को लिखने और पढ़ने के लिए, किसी को IO मॉड्यूल में फ़ंक्शन का उपयोग करना चाहिए। डिफ़ॉल्ट रूप से, एक फ़ाइल खोली जाती है :binary मोड, जिसमें फ़ाइल के साथ इंटरैक्ट करने के लिए IO.binread/2 और IO.binwrite/2 फ़ंक्शन की आवश्यकता होती है। एक डेवलपर पास हो सकता है :utf8 फ़ाइल खोलने पर एक विकल्प के रूप में :utf8 और फिर IO से अन्य सभी फ़ंक्शन उपलब्ध हैं, क्योंकि वे सीधे यूनिकोड डेटा के साथ काम करते हैं।

modes_or_function या तो मोड या फ़ंक्शन की सूची हो सकती है। यदि यह एक सूची है, तो इसे मोड की एक सूची माना जाता है (जो नीचे प्रलेखित हैं)। यदि यह एक फ़ंक्शन है, तो यह कॉलिंग open(path, [], modes_or_function) के बराबर है। इस फ़ंक्शन की अधिक जानकारी के लिए open/3 लिए दस्तावेज़ देखें।

अनुमत मोड:

  • :binary - फ़ाइल को बाइनरी मोड में खोलता है, जो यूनिकोड अनुक्रमों (डिफॉल्ट मोड) की विशेष हैंडलिंग को अक्षम करता है।

  • :read - फ़ाइल, जिसमें मौजूद होना चाहिए, पढ़ने के लिए खोला गया है।

  • :write - फाइल लिखने के लिए खोला जाता है। इसका निर्माण होता है यदि यह मौजूद नहीं है।

    यदि फ़ाइल मौजूद नहीं है, और यदि लिखने को पढ़ने के साथ नहीं जोड़ा गया है, तो फ़ाइल काट दी जाएगी।

  • :append - फ़ाइल लेखन के लिए खोली जाएगी, और अगर यह मौजूद नहीं है तो इसे बनाया जाएगा। परिशिष्ट के साथ खोली गई फ़ाइल के लिए हर लिखने का कार्य फ़ाइल के अंत में होगा।

  • :exclusive - फ़ाइल, जब लिखने के लिए खोला जाता है, तो यह मौजूद नहीं होने पर बनाई जाती है। यदि फ़ाइल मौजूद है, तो खुला {:error, :eexist} वापस {:error, :eexist}

  • :charlist - जब यह शब्द दिया जाता है, तो फ़ाइल पर पढ़ा गया संचालन बायलेरिज़ के बजाय charlists को लौटा देगा।

  • :compressed - gzip संपीड़ित फ़ाइलों को पढ़ना या लिखना संभव बनाता है।

    संपीड़ित विकल्प को पढ़ने या लिखने के साथ जोड़ा जाना चाहिए, लेकिन दोनों में नहीं। ध्यान दें कि stat/1 साथ प्राप्त फ़ाइल का आकार संभवतः उन बाइट्स की संख्या से मेल नहीं खाएगा जो एक संपीड़ित फ़ाइल से पढ़े जा सकते हैं।

  • :utf8 - यह विकल्प बताता है कि डिस्क फ़ाइल में डेटा वास्तव में कैसे संग्रहीत किया जाता है और यह फ़ाइल को UTF-8 से वर्णों का स्वचालित अनुवाद करता है।

    यदि डेटा एक प्रारूप में फ़ाइल में भेजा जाता है जिसे UTF-8 में परिवर्तित नहीं किया जा सकता है या यदि डेटा को किसी फ़ंक्शन द्वारा पढ़ा जाता है जो डेटा को उस प्रारूप में लौटाता है जो डेटा की वर्ण सीमा के साथ सामना नहीं कर सकता है, तो एक त्रुटि होती है और फ़ाइल बंद रहेगा।

  • :delayed_write :raw :ram :read_ahead :sync , {:encoding, ...} , {:read_ahead, pos_integer} , {:delayed_write, non_neg_integer, non_neg_integer} - इन विकल्पों के बारे में अधिक जानकारी के लिए देखें :file.open/2

यह फ़ंक्शन देता है:

  • {:ok, io_device} - फ़ाइल अनुरोधित मोड में खोली गई है।

    io_device वास्तव में उस प्रक्रिया का PID है जो फ़ाइल को संभालता है। यह प्रक्रिया उस प्रक्रिया से जुड़ी हुई है जिसने मूल रूप से फ़ाइल को खोला है। यदि किसी भी प्रक्रिया को io_device लिंक किया गया है, तो फ़ाइल बंद हो जाएगी और यह प्रक्रिया स्वयं समाप्त हो जाएगी।

    इस कॉल से लौटे io_device को IO मॉड्यूल फ़ंक्शन के लिए एक तर्क के रूप में उपयोग किया जा सकता है।

  • {:error, reason} - फ़ाइल को खोला नहीं जा सका।

उदाहरण

{:ok, file} = File.open("foo.tar.gz", [:read, :compressed])
IO.read(file, :line)
File.close(file)

खुला (पथ, मोड, फ़ंक्शन)

open(Path.t(), [mode() | :ram], (io_device() -> res)) ::
  {:ok, res} | {:error, posix()}
when res: var

open/2 समान लेकिन किसी फ़ंक्शन को उसके अंतिम तर्क के रूप में लेने की अपेक्षा करता है।

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

रिटर्न {:ok, function_result} सफलता के मामले में, {:error, reason} अन्यथा।

यह फ़ंक्शन अपेक्षा करता है कि फ़ाइल को सफलता के साथ बंद कर दिया जाए, जो कि आमतौर पर मामला है :delayed_write जब तक :delayed_write विकल्प नहीं दिया जाता है। इस कारण से, हम पास करने की अनुशंसा नहीं करते हैं :delayed_write इस फ़ंक्शन में :delayed_write से :delayed_write

उदाहरण

File.open("file.txt", [:read, :write], fn(file) ->
  IO.read(file, :line)
end)

उपलब्ध modes की सूची के लिए open/2 देखें।

पढ़ें! (पथ)

read!(Path.t()) :: binary() | no_return()

दिए गए फ़ाइल नाम की सामग्री के साथ एक द्विआधारी लौटाता है या यदि कोई त्रुटि होती है तो फ़ाइल को उठाता है।

पढ़ा (पथ)

read(Path.t()) :: {:ok, binary()} | {:error, posix()}

रिटर्न {:ok, binary} , जहां binary एक बाइनरी डेटा ऑब्जेक्ट है जिसमें path की सामग्री होती path , या यदि त्रुटि होती है {:error, reason} तो {:error, reason}

विशिष्ट त्रुटि कारण:

  • :enoent - फ़ाइल मौजूद नहीं है
  • :eacces - फाइल को पढ़ने के लिए, या माता-पिता में से किसी एक निर्देशिका को खोजने की अनुमति न :eacces
  • :eisdir - नामित फ़ाइल एक निर्देशिका है
  • :enotdir - फ़ाइल नाम का एक घटक निर्देशिका नहीं है; कुछ प्लेटफार्मों पर :enoent को इसके बदले लौटाया जाता है
  • :enomem - फ़ाइल की सामग्री के लिए पर्याप्त मेमोरी नहीं है

आप त्रुटि का वर्णनात्मक स्ट्रिंग प्राप्त करने के लिए :file.format_error/1 का उपयोग कर सकते हैं।

read_link! (पथ) (1.5.0 से)

read_link!(Path.t()) :: binary() | no_return()

read_link/1 रूप में समान है, लेकिन सीधे लक्ष्य देता है या यदि कोई त्रुटि वापस File.Error तो File.Error फेंकता है।

read_link (पथ) (1.5.0 से)

read_link(Path.t()) :: {:ok, binary()} | {:error, posix()}

path पर प्रतीकात्मक लिंक पढ़ता है।

यदि path मौजूद है और एक सिमलिंक है, तो {:ok, target} , अन्यथा रिटर्न {:error, reason}

अधिक जानकारी के लिए, देखें :file.read_link/1

विशिष्ट त्रुटि कारण हैं:

  • :einval - पथ प्रतीकात्मक लिंक नहीं है
  • :enoent - पथ मौजूद नहीं है
  • :enotsup - प्रतीकात्मक लिंक वर्तमान प्लेटफॉर्म पर समर्थित नहीं हैं

नियमित रूप से? (पथ)

regular?(Path.t()) :: boolean()

यदि पथ एक नियमित फ़ाइल है, तो true है।

यह फ़ंक्शन प्रतीकात्मक लिंक का अनुसरण करता है, इसलिए यदि एक प्रतीकात्मक लिंक एक नियमित फ़ाइल की ओर इशारा करता है, तो true वापस आ जाता है।

उदाहरण

File.regular? __ENV__.file #=> true

नाम बदलें (स्रोत, गंतव्य)

rename(Path.t(), Path.t()) :: :ok | {:error, posix()}

destination फ़ाइल के लिए source फ़ाइल का नाम बदलता है। इसका उपयोग निर्देशिकाओं के बीच फ़ाइलों (और निर्देशिकाओं) को स्थानांतरित करने के लिए किया जा सकता है। यदि कोई फ़ाइल चलती है, तो आपको destination फ़ाइल नाम को पूरी तरह से निर्दिष्ट करना होगा, यह केवल इसकी निर्देशिका निर्दिष्ट करने के लिए पर्याप्त नहीं है।

रिटर्न :ok सफलता के मामले में :ok है, {:error, reason} अन्यथा।

नोट: यूनिक्स सिस्टम में कमांड mv अलग तरीके से व्यवहार करता है यदि source एक फ़ाइल है और destination एक मौजूदा निर्देशिका है। हमने इस व्यवहार को स्पष्ट रूप से अस्वीकार करने के लिए चुना है।

उदाहरण

# Rename file "a.txt" to "b.txt"
File.rename "a.txt", "b.txt"

# Rename directory "samples" to "tmp"
File.rename "samples", "tmp"

rm! (पथ)

rm!(Path.t()) :: :ok | no_return()

rm/1 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

rm (पथ)

rm(Path.t()) :: :ok | {:error, posix()}

फ़ाइल path को हटाने का प्रयास करता path

रिटर्न :ok अगर सफल, या {:error, reason} यदि कोई त्रुटि होती है।

नोट केवल-पढ़ने के लिए मोड में भी फ़ाइल को हटा दिया गया है।

विशिष्ट त्रुटि कारण हैं:

  • :enoent - फ़ाइल मौजूद नहीं है
  • :eacces - फ़ाइल या उसके माता-पिता में से एक के लिए लापता अनुमति
  • :eperm - फ़ाइल एक निर्देशिका है और उपयोगकर्ता सुपर-उपयोगकर्ता नहीं है
  • :enotdir - फ़ाइल नाम का एक घटक निर्देशिका नहीं है; कुछ प्लेटफार्मों पर :enoent को इसके बदले लौटाया जाता है
  • :einval - फ़ाइल नाम में एक अनुचित प्रकार था, जैसे :einval

उदाहरण

File.rm("file.txt")
#=> :ok

File.rm("tmp_dir/")
#=> {:error, :eperm}

rm_rf! (पथ)

rm_rf!(Path.t()) :: [binary()] | no_return()

rm_rf/1 रूप में भी लेकिन विफलताओं के मामले में File.Error को उठाता है, अन्यथा फ़ाइलों या निर्देशिकाओं की सूची हटा दी जाती है।

rm_rf (पथ)

rm_rf(Path.t()) :: {:ok, [binary()]} | {:error, posix(), binary()}

फ़ाइलों और निर्देशिकाओं को दिए गए path पर पुन: हटाता path । साइमलिंक का पालन नहीं किया जाता है लेकिन बस हटा दिया जाता है, गैर-मौजूदा फ़ाइलों को केवल अनदेखा किया जाता है (यानी यह फ़ंक्शन विफल नहीं करता है)।

रिटर्न {:ok, files_and_directories} सभी फ़ाइलों और निर्देशिकाओं को बिना किसी विशिष्ट क्रम में निकाले, {:error, reason, file} अन्यथा।

उदाहरण

File.rm_rf "samples"
#=> {:ok, ["samples", "samples/1.txt"]}

File.rm_rf "unknown"
#=> {:ok, []}

rmdir! (पथ)

rmdir!(Path.t()) :: :ok | {:error, posix()}

rmdir/1 रूप में भी, लेकिन विफलता के मामले में एक अपवाद को जन्म देता है। अन्यथा :ok

rmdir (पथ)

rmdir(Path.t()) :: :ok | {:error, posix()}

path में डायर को हटाने की कोशिश करता path

रिटर्न :ok अगर सफल, या {:error, reason} यदि कोई त्रुटि होती है। यदि निर्देशिका खाली नहीं है, तो यह {:error, :eexist} है।

उदाहरण

File.rmdir("tmp_dir")
#=> :ok

File.rmdir("non_empty_dir")
#=> {:error, :eexist}

File.rmdir("file.txt")
#=> {:error, :enotdir}

स्टेट! (पथ, opts \\ [])

stat!(Path.t(), stat_options()) :: File.Stat.t() | no_return()

stat/2 रूप में समान है, लेकिन File.Stat वापस लौटाता है। सीधे File.Stat करें, या File.Error फेंकता है File.Error यदि कोई त्रुटि वापस File.Error तो।

स्टेट (पथ, opts \\ [])

stat(Path.t(), stat_options()) :: {:ok, File.Stat.t()} | {:error, posix()}

path बारे में जानकारी देता है। यदि यह मौजूद है, तो यह एक {:ok, info} tuple देता है, जहां जानकारी एक File.Stat संरचना है। रिटर्न {:error, reason} उसी कारणों के साथ जैसे read(path) यदि फेल होता है।

विकल्प

स्वीकृत विकल्प हैं:

  • :time - कॉन्फ़िगर करता है कि फ़ाइल टाइमस्टैम्प कैसे लौटाए जाते हैं

इसके लिए मान हो सकते हैं :time :

  • :universal - यूटीसी (डिफ़ॉल्ट) में एक {date, time} टपल लौटाता है
  • :local - मशीन के समान समय क्षेत्र का उपयोग करके {date, time} टपल लौटाता है
  • :posix - युग के बाद से पूर्णांक सेकंड के रूप में समय देता है

स्ट्रीम (पथ, मोड \\ [], line_or_bytes \\: लाइन)

stream!(Path.t(), stream_mode(), :line | pos_integer()) :: File.Stream.t()

दिए गए modes साथ दिए गए path लिए एक File.Stream लौटाता है।

स्ट्रीम Enumerable और Collectable प्रोटोकॉल दोनों को लागू करता है, जिसका अर्थ है कि इसका उपयोग पढ़ने और लिखने दोनों के लिए किया जा सकता है।

line_or_bytes तर्क कॉन्फ़िगर करता है कि स्ट्रीमिंग, फ़ाइल :line (डिफ़ॉल्ट) या बाइट्स की दी गई संख्या से कैसे पढ़ा जाता है।

File.open!/2 जैसे कारणों से स्ट्रीम का संचालन खुले में विफल हो सकता है। ध्यान दें कि हर बार स्ट्रीमिंग शुरू होने पर फ़ाइल अपने आप खुल जाती है। पास करने की आवश्यकता नहीं है :read और :write तरीके, जैसे कि वे स्वचालित रूप से अमृत द्वारा निर्धारित होते हैं।

कच्ची फाइलें

चूंकि अमृत फ़ाइल को नियंत्रित करता है जब स्ट्रीम की गई फ़ाइल को खोला जाता है, तो अंतर्निहित डिवाइस को साझा नहीं किया जा सकता है और जैसे प्रदर्शन कारणों से फ़ाइल को कच्चे मोड में खोलना सुविधाजनक है। इसलिए, जब तक एन्कोडिंग निर्दिष्ट नहीं किया जाता है :read_ahead तब तक अमृत मोड में :read_ahead विकल्प के साथ :raw विधा खुल जाएगी । इसका मतलब है कि फ़ाइल में स्ट्रीम किया गया कोई भी डेटा iodata/0 प्रकार में परिवर्तित होना चाहिए। यदि आप उदाहरण के लिए [encoding: :utf8] या [encoding: {:utf16, :little}] मोड पैरामीटर में पास करते हैं, तो अंतर्निहित स्ट्रीम डेटा को परिवर्तित करने के लिए IO.write/2 और String.Chars प्रोटोकॉल का उपयोग करेगा। IO.binwrite/2 और IO.write/2

यदि कोई धारा एक तंग लूप के तहत लिखने के लिए होती है, तो :delayed_write विकल्प को पारित करने पर भी विचार किया जा सकता है।

बाइट ऑर्डर के निशान

यदि आप पास करते हैं :trim_bom मोड पैरामीटर में :trim_bom , फाइल से पढ़ने पर स्ट्रीम UTF-8, UTF-16 और UTF-32 बाइट ऑर्डर मार्क्स को ट्रिम कर देगा।

ध्यान दें कि यह फ़ंक्शन BOM पर फ़ाइल एन्कोडिंग की खोज करने का प्रयास नहीं करता है।

उदाहरण

# Read in 2048 byte chunks rather than lines
File.stream!("./test/test.data", [], 2048)
#=> %File.Stream{line_or_bytes: 2048, modes: [:raw, :read_ahead, :binary],
#=>   path: "./test/test.data", raw: true}

किसी फ़ाइल में स्ट्रीमिंग के उदाहरण के लिए Stream.run/1 देखें।

स्पर्श करें (पथ, समय \\: Calendar.universal_time ())

touch!(Path.t(), :calendar.datetime()) :: :ok | no_return()

के रूप में ही है, touch/2 लेकिन एक अपवाद उठाता है अगर यह विफल रहता है।

:ok अन्यथा लौटता है। UTC में डेटाटाइम की आवश्यकता है।

स्पर्श (पथ, समय \\: Calendar.universal_time ())

touch(Path.t(), :calendar.datetime()) :: :ok | {:error, posix()}

अपडेट किए गए संशोधन समय (माइम) और दिए गए फ़ाइल का एक्सेस समय (Atime)।

यदि यह मौजूद नहीं है तो फ़ाइल बनाई जाती है। UTC में डेटाटाइम की आवश्यकता है।

लिखें (पथ, सामग्री, मोड \\ [])

write!(Path.t(), iodata(), [mode()]) :: :ok | no_return()

के रूप में ही, write/3 लेकिन अगर यह विफल रहता है तो एक अपवाद उठाता है, :ok अन्यथा।

लिखना (पथ, सामग्री, मोड \\ [])

write(Path.t(), iodata(), [mode()]) :: :ok | {:error, posix()}

content फ़ाइल को लिखता है path

यदि मौजूद नहीं है तो फ़ाइल बनाई जाती है। यदि यह मौजूद है, तो पिछली सामग्री ओवरराइट की गई है। :ok सफल होने पर, या {:error, reason} यदि कोई त्रुटि होती है , तो लौटाता है।

content होना चाहिए iodata (बाइट या बाइनरी की एक सूची)। इस फ़ंक्शन के लिए एन्कोडिंग सेट करने का कोई प्रभाव नहीं है।

चेतावनी: हर बार इस फ़ंक्शन को लागू करने के बाद, एक फ़ाइल डिस्क्रिप्टर खोला जाता है और फ़ाइल पर लिखने के लिए एक नई प्रक्रिया शुरू की जाती है। इस कारण से, यदि आप एक लूप में कई राइट्स कर रहे हैं, तो फाइल को लिखने के लिए File.open/2 फंक्शन्स का उपयोग करके फाइल को खोलना और IO कई बार इस फंक्शन को कॉल करने की तुलना में बेहतर परफॉर्मेंस देगा।

विशिष्ट त्रुटि कारण हैं:

  • :enoent - फ़ाइल नाम का एक घटक मौजूद नहीं है
  • :enotdir - फ़ाइल नाम का एक घटक निर्देशिका नहीं है; कुछ प्लेटफार्मों पर, :enoent इसके बजाय वापस कर दिया जाता है
  • :enospc - डिवाइस पर कोई जगह नहीं बची है
  • :eacces - फ़ाइल लिखने या मूल निर्देशिका में से किसी एक को खोजने की अनुमति न मिलना
  • :eisdir - नामित फ़ाइल एक निर्देशिका है

File.open/2 अन्य उपलब्ध विकल्पों के लिए जाँच करें।

write_stat! (पथ, स्टेट, opts \\ [])

write_stat!(Path.t(), File.Stat.t(), stat_options()) :: :ok | no_return()

के रूप में ही है, write_stat/3 लेकिन एक अपवाद उठाता है अगर यह विफल रहता है। :ok अन्यथा लौटता है।

write_stat (पथ, स्टेट, opts \\ [])

write_stat(Path.t(), File.Stat.t(), stat_options()) :: :ok | {:error, posix()}

दिए File.Stat गए पथ पर फ़ाइल सिस्टम पर वापस दिए गए को लिखता है । लौटाता है :ok या {:error, reason}

Original text