Elixir 1.7

IO




elixir

IO

इनपुट / आउटपुट (IO) को संभालने वाले कार्य।

इस मॉड्यूल में कई कार्य एक तर्क के रूप में IO डिवाइस की अपेक्षा करते हैं। एक IO डिवाइस एक PID या एक परमाणु होना चाहिए जो एक प्रक्रिया का प्रतिनिधित्व करता है। सुविधा के लिए, एलिक्जिर प्रदान करता है :stdio के :standard_io और :standard_error शॉर्टकट के रूप में :stdio और :stderr

बहुसंख्यक कार्य वर्णार्थ अर्थात वर्णों और तारों की सूची या सूची की अपेक्षा करते हैं। यदि कोई अन्य प्रकार दिया जाता है, तो फ़ंक्शन स्ट्रिंग के माध्यम से स्ट्रिंग में परिवर्तित हो जाएंगे। String.Chars प्रोटोकॉल (जैसा कि टाइपस्पेस में दिखाया गया है)।

bin साथ शुरू होने वाले कार्य एक तर्क के रूप में iodata की उम्मीद करते हैं, अर्थात बायनेरिज़ या बाइट्स और बायनेरिज़ की सूची।

IO उपकरणों

एक IO उपकरण एक परमाणु या एक PID हो सकता है। यदि यह एक परमाणु है, तो परमाणु एक पंजीकृत प्रक्रिया का नाम होना चाहिए। इसके अलावा, अमृत दो शॉर्टकट प्रदान करता है:

  • :stdio - के लिए एक शॉर्टकट :standard_io , जो वर्तमान Process.group_leader/0 लिए मैप करता है Erlang में

  • :stderr - नामित प्रक्रिया के लिए एक शॉर्टकट :standard_error Erlang में प्रदान किया गया :standard_error

IO उपकरण अपनी स्थिति बनाए रखते हैं, जिसका अर्थ है कि किसी भी पढ़ने या लिखने के कार्यों के लिए बाद की कॉल उस स्थान से शुरू होगी जहां उपकरण अंतिम बार पहुँचा था। फ़ाइलों की स्थिति का उपयोग करके बदला जा सकता है :file.position/2 फ़ंक्शन।

सारांश

प्रकार

chardata()
device()
nodata()

कार्य

बिन्रेड (डिवाइस \\: stdio, line_or_chars)

आईओ device से पढ़ता device । ऑपरेशन यूनिकोड असुरक्षित है

binstream (उपकरण, लाइन_ओर_बाइट्स)

IO device को IO.Stream में परिवर्तित करता है। ऑपरेशन यूनिकोड असुरक्षित है

बिनराइट (डिवाइस \\: stdio, आइटम)

item को दिए गए device बाइनरी के रूप में लिखता device । कोई यूनिकोड रूपांतरण नहीं होता है। ऑपरेशन यूनिकोड असुरक्षित है

chardata_to_string(string)

एक तार में चारधाता (कोडपॉइंट्स, सूचियों और तारों का प्रतिनिधित्व करने वाले पूर्णांक की एक सूची) को परिवर्तित करता है

getn (शीघ्र, गिनती \\ 1)

IO डिवाइस से कई बाइट्स :stdio

getn (उपकरण, शीघ्र, गिनती)

IO device से कई बाइट्स मिलते हैं

हो जाता है (डिवाइस \\: stdio, शीघ्र)

IO device से एक लाइन पढ़ता device

निरीक्षण (आइटम, opts \\ [])

डिवाइस को दिए गए item का निरीक्षण करता है और लिखता है

निरीक्षण (उपकरण, आइटम, ऑप्स)

आईओ device का उपयोग करके दिए गए विकल्पों के अनुसार item निरीक्षण करता device

iodata_length(item)

आयोडेट का आकार देता है

iodata_to_binary(item)

आयोडेटा (बाइट्स, सूची और बायनेरिज़ का प्रतिनिधित्व करने वाले पूर्णांक की एक सूची) को एक बाइनरी में परिवर्तित करता है। ऑपरेशन यूनिकोड असुरक्षित है

डालता है (डिवाइस \\: stdio, आइटम)

दिए गए device को write/2 समान item लिखता है, लेकिन अंत में एक नई पंक्ति जोड़ता है

पढ़ें (डिवाइस \\: stdio, line_or_chars)

आईओ device से पढ़ता device

स्ट्रीम (डिवाइस, लाइन_or_codepoint)

IO device को IO.Stream में परिवर्तित करता है

warn(message)

Stderr को एक message लिखता है, साथ ही साथ वर्तमान स्टैकट्रेस

चेतावनी (संदेश, स्टैकट्रेस)

दिए गए stacktrace के साथ, stderr को message लिखता है

write/2

दिए गए device item लिखता device

प्रकार

chardata ()

chardata() :: :unicode.chardata()

डिवाइस ()

device() :: atom() | pid()

कोई आकड़ा उपलब्ध नहीं है()

nodata() :: {:error, term()} | :eof

कार्य

बिन्रेड (डिवाइस \\: stdio, line_or_chars)

binread(device(), :all | :line | non_neg_integer()) :: iodata() | nodata()

आईओ device से पढ़ता device । ऑपरेशन यूनिकोड असुरक्षित है।

device को बाइट्स की दी गई संख्या या लाइन द्वारा लाइन द्वारा पुनरावृत्त किया जाता है यदि :line दी गई हो। वैकल्पिक रूप से, यदि :all दिया जाता है, तो पूरे device को लौटा दिया जाता है।

यह रिटर्न:

  • data - आउटपुट बाइट्स

  • :eof - फ़ाइल का अंत सामने आया था

  • {:error, reason} - अन्य (दुर्लभ) त्रुटि स्थिति; उदाहरण के लिए, {:error, :estale} यदि NFS वॉल्यूम से पढ़ रहा है

यदि :all दिया जाता है :eof कभी वापस नहीं किया जाता है, लेकिन डिवाइस ईओएफ तक पहुंचने के मामले में एक खाली स्ट्रिंग है।

नोट: इस फ़ंक्शन का उपयोग यूनिकोड मोड में IO उपकरणों पर न करें क्योंकि यह गलत परिणाम देगा।

binstream (उपकरण, लाइन_ओर_बाइट्स)

binstream(device(), :line | pos_integer()) :: Enumerable.t()

IO device को IO.Stream में परिवर्तित करता है। ऑपरेशन यूनिकोड असुरक्षित है।

एक IO.Stream Enumerable और Collectable दोनों को लागू करता है, इसे पढ़ने और लिखने दोनों के लिए उपयोग करने की अनुमति देता है।

device को बाइट्स की दी गई संख्या या लाइन द्वारा लाइन द्वारा पुनरावृत्त किया जाता है यदि :line दी गई हो। यह एक कच्चे बाइनरी के रूप में IO डिवाइस से पढ़ता है।

ध्यान दें कि एक IO स्ट्रीम में साइड इफेक्ट होते हैं और हर बार जब आप स्ट्रीम पर जाते हैं तो आपको अलग-अलग परिणाम मिल सकते हैं।

अंत में, इस फ़ंक्शन का उपयोग यूनिकोड मोड में IO उपकरणों पर न करें क्योंकि यह गलत परिणाम देगा।

बिनराइट (डिवाइस \\: stdio, आइटम)

binwrite(device(), iodata()) :: :ok | {:error, term()}

item को दिए गए device बाइनरी के रूप में लिखता device । कोई यूनिकोड रूपांतरण नहीं होता है। ऑपरेशन यूनिकोड असुरक्षित है।

अधिक जानकारी के लिए write/2 जांचें।

नोट: इस फ़ंक्शन का उपयोग यूनिकोड मोड में IO उपकरणों पर न करें क्योंकि यह गलत परिणाम देगा।

chardata_to_string (स्ट्रिंग)

chardata_to_string(chardata()) :: String.t() | no_return()

एक तार में चारधाता (कोडपॉइंट्स, सूचियों और तारों का प्रतिनिधित्व करने वाले पूर्णांक की एक सूची) को परिवर्तित करता है।

यदि रूपांतरण विफल हो जाता है, तो यह एक UnicodeConversionError जन्म UnicodeConversionError । यदि कोई स्ट्रिंग दी जाती है, तो वह स्ट्रिंग को ही लौटा देती है।

उदाहरण

iex> IO.chardata_to_string([0x00E6, 0x00DF])
"æß"

iex> IO.chardata_to_string([0x0061, "bc"])
"abc"

iex> IO.chardata_to_string("string")
"string"

getn (शीघ्र, गिनती \\ 1)

getn(device(), chardata() | String.Chars.t()) :: chardata() | nodata()
getn(chardata() | String.Chars.t(), pos_integer()) :: chardata() | nodata()

IO डिवाइस से कई बाइट्स :stdio

यदि :stdio एक यूनिकोड डिवाइस है, तो इसका मतलब है कि यूनिकोड कोडपॉइंट्स की संख्या को पुनः प्राप्त किया जाना है। अन्यथा, count को पुनर्प्राप्त करने के लिए कच्चे बाइट्स की संख्या है।

रिटर्न मानों के विवरण के लिए IO.getn/3 देखें।

getn (उपकरण, शीघ्र, गिनती)

getn(device(), chardata() | String.Chars.t(), pos_integer()) ::
  chardata() | nodata()

IO device से कई बाइट्स मिलते हैं।

यदि IO device एक यूनिकोड डिवाइस है, तो count का अर्थ है कि यूनिकोड कोडपॉइंट्स की संख्या को पुनः प्राप्त किया जाना है। अन्यथा, count को पुनर्प्राप्त करने के लिए कच्चे बाइट्स की संख्या है।

यह रिटर्न:

  • data - इनपुट वर्ण

  • :eof - फ़ाइल का अंत सामने आया था

  • {:error, reason} - अन्य (दुर्लभ) त्रुटि स्थिति; उदाहरण के लिए, {:error, :estale} यदि NFS वॉल्यूम से पढ़ रहा है

हो जाता है (डिवाइस \\: stdio, शीघ्र)

gets(device(), chardata() | String.Chars.t()) :: chardata() | nodata()

IO device से एक लाइन पढ़ता device

यह रिटर्न:

  • data - लाइन में अक्षर-लाइन (LF) या फ़ाइल के अंत (EOF) द्वारा समाप्त

  • :eof - फ़ाइल का अंत सामने आया था

  • {:error, reason} - अन्य (दुर्लभ) त्रुटि स्थिति; उदाहरण के लिए, {:error, :estale} यदि NFS वॉल्यूम से पढ़ रहा है

उदाहरण

एक त्वरित और प्रतीक्षित उपयोगकर्ता इनपुट के रूप में "आपका नाम क्या है?"

IO.gets "What is your name?\n"

निरीक्षण (आइटम, opts \\ [])

inspect(item, keyword()) :: item when item: var

डिवाइस को दिए गए item का निरीक्षण करता है और लिखता है।

यह ध्यान रखना महत्वपूर्ण है कि यह दी गई item अपरिवर्तित लौटाता है। यह आपके कोड में लगभग कहीं भी एक IO.inspect/2 कॉल डालने से मूल्यों पर "जासूसी" करना संभव बनाता है, उदाहरण के लिए, पाइप लाइन के बीच में।

यह 80 अक्षरों की चौड़ाई के साथ डिफ़ॉल्ट रूप से सुंदर प्रिंटिंग को सक्षम बनाता है। चौड़ाई को स्पष्ट रूप से पास करके बदला जा सकता है :width विकल्प।

आउटपुट को लेबल के साथ सजाया जा सकता है :label विकल्प को आसानी से अन्य IO.inspect/2 कॉल से अलग करने के लिए। लेबल को निरीक्षण किए गए item से पहले मुद्रित किया जाएगा।

शेष प्रारूपण विकल्पों की पूरी सूची के लिए Inspect.Opts देखें।

उदाहरण

IO.inspect <<0, 1, 2>>, width: 40

प्रिंटों:

<<0, 1, 2>>

हम आउटपुट को सजाने के लिए :label विकल्प का उपयोग कर सकते हैं:

IO.inspect 1..100, label: "a wonderful range"

प्रिंटों:

a wonderful range: 1..100

:label विकल्प पाइपलाइनों के साथ विशेष रूप से उपयोगी है:

[1, 2, 3]
|> IO.inspect(label: "before")
|> Enum.map(&(&1 * 2))
|> IO.inspect(label: "after")
|> Enum.sum

प्रिंटों:

before: [1, 2, 3]
after: [2, 4, 6]

निरीक्षण (उपकरण, आइटम, ऑप्स)

inspect(device(), item, keyword()) :: item when item: var

आईओ device का उपयोग करके दिए गए विकल्पों के अनुसार item निरीक्षण करता device

विकल्पों की पूरी सूची के लिए inspect/2 देखें।

iodata_length (आइटम)

iodata_length(iodata()) :: non_neg_integer()

आयोडेट का आकार देता है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> IO.iodata_length([1, 2 | <<3, 4>>])
4

iodata_to_binary (आइटम)

iodata_to_binary(iodata()) :: binary()

आयोडेटा (बाइट्स, सूची और बायनेरिज़ का प्रतिनिधित्व करने वाले पूर्णांक की एक सूची) को एक बाइनरी में परिवर्तित करता है। ऑपरेशन यूनिकोड असुरक्षित है।

ध्यान दें कि यह फ़ंक्शन कच्चे बाइट्स के रूप में पूर्णांकों की सूचियों को मानता है और किसी भी प्रकार के एन्कोडिंग रूपांतरण का प्रदर्शन नहीं करता है। यदि आप एक चार्जलिस्ट से स्ट्रिंग (UTF-8 एन्कोडेड) में बदलना चाहते हैं, तो कृपया इसके बजाय chardata_to_string(string) उपयोग करें।

यदि यह फ़ंक्शन एक बाइनरी प्राप्त करता है, तो एक ही बाइनरी वापस आ जाती है।

संकलक द्वारा झुका हुआ।

उदाहरण

iex> bin1 = <<1, 2, 3>>
iex> bin2 = <<4, 5>>
iex> bin3 = <<6>>
iex> IO.iodata_to_binary([bin1, 1, [2, 3, bin2], 4 | bin3])
<<1, 2, 3, 1, 2, 3, 4, 5, 4, 6>>

iex> bin = <<1, 2, 3>>
iex> IO.iodata_to_binary(bin)
<<1, 2, 3>>

डालता है (डिवाइस \\: stdio, आइटम)

puts(device(), chardata() | String.Chars.t()) :: :ok

दिए गए device को write/2 समान item लिखता है, लेकिन अंत में एक नई पंक्ति जोड़ता है।

डिफ़ॉल्ट रूप से, device मानक आउटपुट है। यह वापस आता है :ok अगर यह सफल होता है।

उदाहरण

IO.puts "Hello World!"
#=> Hello World!

IO.puts :stderr, "error"
#=> error

पढ़ें (डिवाइस \\: stdio, line_or_chars)

read(device(), :all | :line | non_neg_integer()) :: chardata() | nodata()

आईओ device से पढ़ता device

device को वर्णों की दी गई संख्या या लाइन द्वारा लाइन द्वारा पुनरावृत्त किया जाता है यदि :line दी गई हो। वैकल्पिक रूप से, यदि :all दिया जाता है, तो पूरे device को लौटा दिया जाता है।

यह रिटर्न:

  • data - आउटपुट वर्ण

  • :eof - फ़ाइल का अंत सामने आया था

  • {:error, reason} - अन्य (दुर्लभ) त्रुटि स्थिति; उदाहरण के लिए, {:error, :estale} यदि NFS वॉल्यूम से पढ़ रहा है

यदि :all दिया जाता है :eof कभी वापस नहीं किया जाता है, लेकिन डिवाइस ईओएफ तक पहुंचने के मामले में एक खाली स्ट्रिंग है।

स्ट्रीम (डिवाइस, लाइन_or_codepoint)

stream(device(), :line | pos_integer()) :: Enumerable.t()

IO device को IO.Stream में परिवर्तित करता है।

एक IO.Stream Enumerable और Collectable दोनों को लागू करता है, इसे पढ़ने और लिखने दोनों के लिए उपयोग करने की अनुमति देता है।

device को वर्णों की दी गई संख्या या लाइन द्वारा लाइन द्वारा पुनरावृत्त किया जाता है यदि :line दी गई हो।

यह IO से UTF-8 के रूप में पढ़ता है। कच्चे बाइनरी के रूप में IO को संभालने के लिए IO.binstream/2

ध्यान दें कि एक IO स्ट्रीम में साइड इफेक्ट होते हैं और हर बार जब आप स्ट्रीम पर जाते हैं तो आपको अलग-अलग परिणाम मिल सकते हैं।

उदाहरण

यहां एक उदाहरण है कि हम कमांड लाइन से एक इको सर्वर की नकल कैसे करते हैं:

Enum.each IO.stream(:stdio, :line), &IO.write(&1)

चेतावनी दी है (संदेश)

warn(chardata() | String.Chars.t()) :: :ok

Stderr को एक message लिखता है, साथ ही साथ वर्तमान स्टैकट्रेस।

यह वापस आता है :ok अगर यह सफल होता है।

उदाहरण

IO.warn "variable bar is unused"
#=> warning: variable bar is unused
#=>   (iex) evaluator.ex:108: IEx.Evaluator.eval/4

चेतावनी (संदेश, स्टैकट्रेस)

warn(chardata() | String.Chars.t(), Exception.stacktrace()) :: :ok

दिए गए stacktrace के साथ, stderr को message लिखता है।

यह फ़ंक्शन यह भी सूचित करता है कि संकलक एक चेतावनी मुद्रित किया गया था (मामले में - जैसे-त्रुटियां सक्षम की गईं)। यह वापस आता है :ok अगर यह सफल होता है।

स्टैकट्रेस प्रिंटिंग से बचने के लिए एक खाली सूची पारित की जा सकती है।

उदाहरण

stacktrace = [{MyApp, :main, 1, [file: 'my_app.ex', line: 4]}]
IO.warn "variable bar is unused", stacktrace
#=> warning: variable bar is unused
#=>   my_app.ex:4: MyApp.main/1

लिखना (डिवाइस \\: stdio, आइटम)

write(device(), chardata() | String.Chars.t()) :: :ok

दिए गए device item लिखता device

डिफ़ॉल्ट रूप से, device मानक आउटपुट है।

उदाहरण

IO.write "sample"
#=> sample

IO.write :stderr, "error"
#=> error