Elixir 1.7

StringIO




elixir

StringIO

एक IO डिवाइस प्रक्रिया को नियंत्रित करता है जो एक तार लपेटता है।

एक StringIO IO डिवाइस को IO मॉड्यूल में अधिकांश फ़ंक्शन के लिए "डिवाइस" के रूप में पारित किया जा सकता है।

उदाहरण

iex> {:ok, pid} = StringIO.open("foo")
iex> IO.read(pid, 2)
"fo"

सारांश

कार्य

child_spec(arg)

एक पर्यवेक्षक के तहत इस मॉड्यूल को शुरू करने के लिए एक विनिर्देश देता है

close(pid)

IO डिवाइस को बंद कर देता है और शेष इनपुट / आउटपुट बफ़र्स देता है

contents(pid)

दिए गए IO डिवाइस के लिए वर्तमान इनपुट / आउटपुट बफ़र्स देता है

flush(pid)

आउटपुट बफर को फ्लश करता है और इसकी वर्तमान सामग्री को लौटाता है

खुला (पथ, विकल्प_or_function \\ [])

एक IO डिवाइस बनाता है

खुला (स्ट्रिंग, विकल्प, कार्य)

एक IO डिवाइस बनाता है

कार्य

child_spec (आर्ग)

एक पर्यवेक्षक के तहत इस मॉड्यूल को शुरू करने के लिए एक विनिर्देश देता है।

Supervisor देखें।

करीब (पीआईडी)

close(pid()) :: {:ok, {binary(), binary()}}

IO डिवाइस को बंद कर देता है और शेष इनपुट / आउटपुट बफ़र्स देता है।

उदाहरण

iex> {:ok, pid} = StringIO.open("in")
iex> IO.write(pid, "out")
iex> StringIO.close(pid)
{:ok, {"in", "out"}}

सामग्री (पीआईडी)

contents(pid()) :: {binary(), binary()}

दिए गए IO डिवाइस के लिए वर्तमान इनपुट / आउटपुट बफ़र्स देता है।

उदाहरण

iex> {:ok, pid} = StringIO.open("in")
iex> IO.write(pid, "out")
iex> StringIO.contents(pid)
{"in", "out"}

फ्लश (पीआईडी)

flush(pid()) :: binary()

आउटपुट बफर को फ्लश करता है और इसकी वर्तमान सामग्री को लौटाता है।

उदाहरण

iex> {:ok, pid} = StringIO.open("in")
iex> IO.write(pid, "out")
iex> StringIO.flush(pid)
"out"
iex> StringIO.contents(pid)
{"in", ""}

खुला (पथ, विकल्प_or_function \\ [])

open(binary(), (pid() -> res)) :: {:ok, res} when res: var
open(binary(), keyword()) :: {:ok, pid()}

एक IO डिवाइस बनाता है।

string नव निर्मित डिवाइस का प्रारंभिक इनपुट होगा।

options_or_function विकल्प या फ़ंक्शन की एक कीवर्ड सूची हो सकती है।

यदि विकल्प प्रदान किए जाते हैं, तो परिणाम {:ok, pid} , जो बनाए गए IO डिवाइस को लौटाएगा। विकल्प :capture_prompt , जब true सेट किया जाता true , तो डिवाइस के आउटपुट में शामिल किए जाने के लिए संकेत देता है (जो IO.get* फ़ंक्शन के तर्क के रूप में निर्दिष्ट हैं)।

यदि कोई फ़ंक्शन प्रदान किया जाता है, तो डिवाइस बनाया जाएगा और फ़ंक्शन को भेजा जाएगा। जब फ़ंक्शन वापस आता है, तो डिवाइस बंद हो जाएगा। अंतिम परिणाम के साथ एक ट्यूपल होगा :ok और फ़ंक्शन का परिणाम।

उदाहरण

iex> {:ok, pid} = StringIO.open("foo")
iex> IO.gets(pid, ">")
"foo"
iex> StringIO.contents(pid)
{"", ""}

iex> {:ok, pid} = StringIO.open("foo", capture_prompt: true)
iex> IO.gets(pid, ">")
"foo"
iex> StringIO.contents(pid)
{"", ">"}

iex> StringIO.open("foo", fn(pid) ->
...>   input = IO.gets(pid, ">")
...>   IO.write(pid, "The input was #{input}")
...>   StringIO.contents(pid)
...> end)
{:ok, {"", "The input was foo"}}

खुला (स्ट्रिंग, विकल्प, फ़ंक्शन) (1.7.0 के बाद से)

open(binary(), keyword(), (pid() -> res)) :: {:ok, res} when res: var

एक IO डिवाइस बनाता है।

string नव निर्मित डिवाइस का प्रारंभिक इनपुट होगा।

यदि :capture_prompt विकल्प सही पर सेट true , तो आउटपुट में प्रॉम्प्ट ( IO.get* फ़ंक्शन के तर्क के रूप में निर्दिष्ट) कैप्चर किए जाते हैं।

उपकरण बनाया जाएगा और दिए गए फ़ंक्शन को भेजा जाएगा। जब फ़ंक्शन वापस आता है, तो डिवाइस बंद हो जाएगा। अंतिम परिणाम के साथ एक ट्यूपल होगा :ok और फ़ंक्शन का परिणाम।

उदाहरण

iex> StringIO.open("foo", [], fn(pid) ->
...>   input = IO.gets(pid, ">")
...>   IO.write(pid, "The input was #{input}")
...>   StringIO.contents(pid)
...> end)
{:ok, {"", "The input was foo"}}

iex> StringIO.open("foo", [capture_prompt: true], fn(pid) ->
...>   input = IO.gets(pid, ">")
...>   IO.write(pid, "The input was #{input}")
...>   StringIO.contents(pid)
...> end)
{:ok, {"", ">The input was foo"}}