Elixir 1.7

IEx




elixir

IEx

अमृत ​​का इंटरैक्टिव खोल।

यहां वर्णित कुछ कार्य आपके टर्मिनल के आधार पर उपलब्ध नहीं होंगे। विशेष रूप से, यदि आपको यह कहते हुए संदेश मिलता है कि स्मार्ट टर्मिनल नहीं चलाया जा सकता है, तो यहाँ वर्णित कुछ सुविधाएँ काम नहीं करेंगी।

सहायकों

IEx सहायकों का एक समूह प्रदान करता है। उन्हें शेल में टाइप करके h() IEx.Helpers मॉड्यूल के लिए प्रलेखन के रूप में h() एक्सेस किया जा सकता है।

स्वत: पूर्ण

मॉड्यूल के सार्वजनिक कार्यों या अन्य मॉड्यूल की खोज करने के लिए, एक डॉट द्वारा पीछा किया जाने वाला मॉड्यूल नाम टाइप करें, फिर स्वत: पूर्ण को ट्रिगर करने के लिए टैब दबाएं। उदाहरण के लिए:

Enum.

एक मॉड्यूल उन कार्यों को निर्यात कर सकता है जो सीधे उपयोग करने के लिए नहीं हैं: ये कार्य IEx द्वारा स्वतः पूर्ण नहीं किए जाएंगे। IEx स्वत: पूर्ण नहीं किया जाएगा फ़ंक्शन @doc false , @impl true साथ एनोटेट किया गया @impl true , या फ़ंक्शन जिन्हें स्पष्ट रूप से प्रलेखित नहीं किया गया है और जहां फ़ंक्शन नाम __foo__ के रूप में है।

स्वत: पूर्ण कुछ विंडोज शेल पर उपलब्ध नहीं हो सकता है। --werl शुरू करने पर आपको --werl ध्वज को पास करने की आवश्यकता हो सकती है, जैसा कि काम करने के लिए iex --werl में है। --werl पर्यावरण चर को सेट करके स्थायी रूप से सक्षम किया जा सकता है।

शैल इतिहास

एर्लैंग / ओटीपी 20 से, वीएम में इसे सक्षम करने वाले कुछ झंडे पास करके शेल इतिहास प्राप्त करना संभव है। IEx शुरू करते समय इसे प्रति-आवश्यकता के आधार पर किया जा सकता है:

iex --erl "-kernel shell_history enabled"

यदि आप इसे संपूर्ण रूप से अपने सिस्टम पर सक्षम करना चाहते हैं, तो आप ERL_AFLAGS पर्यावरण चर का उपयोग कर सकते हैं और सुनिश्चित करें कि यह आपके टर्मिनल / शेल कॉन्फ़िगरेशन के अनुसार सेट है।

लिनक्स पर:

export ERL_AFLAGS="-kernel shell_history enabled"

विंडोज पर:

set ERL_AFLAGS "-kernel shell_history enabled"

IEx में अभिव्यक्तियाँ

एक इंटरैक्टिव शेल के रूप में, IEx अभिव्यक्तियों का मूल्यांकन करता है। इसके कुछ दिलचस्प परिणाम हैं जो चर्चा के लायक हैं।

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

दूसरा, IEx आपको कई पंक्तियों में एक अभिव्यक्ति को तोड़ने की अनुमति देता है, क्योंकि यह अमृत में आम है। उदाहरण के लिए:

iex(1)> "ab
...(1)> c"
"ab\nc"

ऊपर दिए गए उदाहरण में, शेल को अधिक इनपुट की उम्मीद होगी जब तक कि वह समापन उद्धरण नहीं पाता। कभी-कभी यह स्पष्ट नहीं होता है कि शेल किस चरित्र की उम्मीद कर रहा है, और उपयोगकर्ता खुद को अपूर्ण अभिव्यक्ति की स्थिति में फंस सकता है, शेल को बाहर करने के अलावा इसे समाप्त करने की कोई क्षमता नहीं है।

इस तरह के मामलों के लिए, एक विशेष ब्रेक-ट्रिगर ( #iex:break ) है जो किसी लाइन पर स्वयं सामना होने पर शेल को किसी भी लंबित अभिव्यक्ति से बाहर निकलने और अपनी सामान्य स्थिति में लौटने के लिए मजबूर करेगा:

iex(1)> ["ab
...(1)> c"
...(1)> "
...(1)> ]
...(1)> #iex:break
** (TokenMissingError) iex:1: incomplete expression

ब्रेक आदेश

IEx के अंदर, Ctrl+C मारने से BREAK मेनू खुल जाएगा। इस मेनू में आप शेल को छोड़ सकते हैं, प्रक्रिया देख सकते हैं और टेबल की जानकारी और बहुत कुछ देख सकते हैं।

खोल से बाहर निकलना

IEx शेल छोड़ने के कुछ तरीके हैं:

  • BREAK मेनू के माध्यम से ( Ctrl+C माध्यम से उपलब्ध) q टाइप करके, एंटर दबाकर
  • Ctrl+C , Ctrl+C मारने से
  • Ctrl+\

यदि आप दूरस्थ शेल से जुड़े हैं, तो यह वियोग के बाद भी जीवित रहता है।

ब्रेकिंग और ब्रेकप्वाइंट

IEx में एलिक्सिर कोड और "प्राइ" पर ब्रेकपॉइंट्स को चलाने की प्रक्रिया में स्थापित करने की क्षमता है। यह डेवलपर को किसी दिए गए फ़ंक्शन के अंदर IEx सत्र चलाने की अनुमति देता है।

IEx.pry/0 का उपयोग तब किया जा सकता है जब आप स्रोत कोड को सीधे संशोधित करने और उसे पुन: जमा करने में सक्षम हों:

def my_fun(arg1, arg2) do
  require IEx; IEx.pry
  ... implementation ...
end

जब कोड निष्पादित किया जाता है, तो यह आपसे आत्मनिरीक्षण की अनुमति मांगेगा।

वैकल्पिक रूप से, आप किसी दिए गए मॉड्यूल, फ़ंक्शन और एरिटी पर कोई नियंत्रण नहीं होने पर ब्रेकपॉइंट सेटअप करने के लिए IEx.break!/4 का उपयोग कर सकते हैं। जबकि IEx.break!/4 अधिक लचीला है, इसके लिए Erlang / OTP 20+ की आवश्यकता होती है और इसमें स्रोत कोड से आयात और उपनाम के बारे में जानकारी नहीं होती है।

उपयोगकर्ता स्विच आदेश

ब्रेक कमांड के अलावा, उपयोगकर्ता स्विच कमांड मेनू में जाने के लिए एक Ctrl+G टाइप कर सकता है। पहुंचने पर, आप अधिक जानकारी प्राप्त करने के लिए h टाइप कर सकते हैं।

इस मेनू में, डेवलपर्स नए गोले शुरू करने और उनके बीच वैकल्पिक करने में सक्षम हैं। आइए इसे एक बार आज़माकर देखते हैं:

User switch command
 --> s 'Elixir.IEx'
 --> c

ऊपर दिया गया कमांड एक नया शेल शुरू करेगा और उससे कनेक्ट होगा। hello नामक एक नया वैरिएबल बनाएं और इसे कुछ मान दें:

hello = :world

अब, पहले शेल पर वापस आते हैं:

User switch command
 --> c 1

अब, hello वैरिएबल को फिर से एक्सेस करने का प्रयास करें:

hello
** (UndefinedFunctionError) undefined function hello/0

ऊपर की कमांड विफल हो जाती है क्योंकि हमने गोले स्विच किए हैं। चूँकि गोले एक दूसरे से अलग-थलग होते हैं, आप एक से दूसरे खोल में परिभाषित चर तक नहीं पहुँच सकते।

उपयोगकर्ता स्विच कमांड का उपयोग मौजूदा सत्र को समाप्त करने के लिए भी किया जा सकता है, उदाहरण के लिए जब मूल्यांकनकर्ता एक अनंत लूप में फंस जाता है या जब आप एक अभिव्यक्ति टाइप करते हुए अटक जाते हैं:

User switch command
 --> i
 --> c

उपयोगकर्ता स्विच कमांड मेनू भी डेवलपर्स को r कमांड का उपयोग करके दूरस्थ गोले से कनेक्ट करने की अनुमति देता है। एक विषय जिस पर हम आगे चर्चा करेंगे।

दूर के गोले

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

आइए इसे एक बार आज़माकर देखते हैं। पहले एक नया शेल शुरू करें:

$ iex --sname foo
iex([email protected])1>

प्रॉम्प्ट में कोष्ठक के बीच की स्ट्रिंग आपके नोड का नाम है। हम node/0 फ़ंक्शन को कॉल करके इसे पुनः प्राप्त कर सकते हैं:

iex([email protected])1> node()
:"[email protected]"
iex([email protected])2> Node.alive?()
true

मज़े के लिए, आइए इस शेल में एक सरल मॉड्यूल को भी परिभाषित करें:

iex([email protected])3> defmodule Hello do
...([email protected])3>   def world, do: "it works!"
...([email protected])3> end

अब, एक और शेल शुरू करते हैं, इसे एक नाम देते हैं:

$ iex --sname bar
iex([email protected])1>

यदि हम Hello.world को भेजने की कोशिश करते हैं, तो यह उपलब्ध नहीं होगा क्योंकि यह केवल दूसरे शेल में परिभाषित किया गया था:

iex([email protected])1> Hello.world
** (UndefinedFunctionError) undefined function Hello.world/0

हालाँकि, हम अन्य शेल से दूरस्थ रूप से कनेक्ट कर सकते हैं। उपयोगकर्ता स्विच प्रॉम्प्ट (Ctrl + G) खोलें और टाइप करें:

User switch command
 --> r '[email protected]' 'Elixir.IEx'
 --> c

अब हम दूरस्थ नोड में जुड़े हुए हैं, जैसा कि संकेत हमें दिखाता है, और हम वहां पर परिभाषित सूचना और मॉड्यूल तक पहुंच सकते हैं:

rem([email protected])1> Hello.world
"it works"

वास्तव में, दूरस्थ गोले से जुड़ना इतना सामान्य है कि हम कमांड लाइन के माध्यम से एक शॉर्टकट प्रदान करते हैं:

$ iex --sname baz --remsh [email protected]

जहां "रिम्स" का अर्थ है "रिमोट शेल"। सामान्य तौर पर, अमृत समर्थन करता है:

  • एक अमृत नोड से एक अमृत नोड से remsh
  • एक सादे Erlang नोड से Elixir नोड (^ G मेनू के माध्यम से) से remsh
  • Elixir नोड से एक सादे Erlang नोड तक remsh (और वहां एक erl शेल प्राप्त करें)

बिना अमृत के एक सुदूर नोड के लिए एक अमृत शेल कनेक्ट करना समर्थित नहीं है

.Iex.exs फ़ाइल

जब शुरू होता है, IEx एक स्थानीय .iex.exs फ़ाइल (वर्तमान कार्यशील निर्देशिका में स्थित) की तलाश करता है, तो एक वैश्विक एक ( ~/.iex.exs पर स्थित) और पहले वाले को लोड करता है (यदि कोई हो)। शेल के संदर्भ में लोड .iex.exs फ़ाइल के कोड का मूल्यांकन किया जाता है। इसलिए, उदाहरण के लिए, .iex.exs फ़ाइल में बंधे हुए या लोड किए गए किसी भी मॉड्यूल को बूट किए जाने के बाद शेल में उपलब्ध किया जाएगा।

उदाहरण के लिए, निम्न .iex.exs फ़ाइल लें:

# Load another ".iex.exs" file
import_file "~/.iex.exs"

# Import some module from lib that may not yet have been defined
import_if_available MyApp.Mod

# Print something before the shell starts
IO.puts "hello world"

# Bind a variable that'll be accessible in the shell
value = 13

IEx उस निर्देशिका में चल रहा है जहाँ उपरोक्त .iex.exs फ़ाइल स्थित है:

$ iex
Erlang 19 [...]

hello world
Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> value
13

--dot-iex लिए --dot-iex विकल्प की आपूर्ति करके किसी अन्य फ़ाइल को लोड करना संभव है। iex --help देखें iex --help

खोल को कॉन्फ़िगर करना

आईईएक्स द्वारा प्रदान किए जाने वाले कई अनुकूलन विकल्प हैं। IEx.configure/1 टाइप करके IEx.configure/1 फ़ंक्शन के डॉक्स पर एक नज़र डालें।

उन विकल्पों को आपकी ~/.iex.exs फ़ाइल से IEx.configure/1 कॉल करके आपकी प्रोजेक्ट कॉन्फ़िगरेशन फ़ाइल या विश्व स्तर पर कॉन्फ़िगर किया जा सकता है। उदाहरण के लिए:

# .iex.exs
IEx.configure(inspect: [limit: 3])

अब शेल चलाएं:

$ iex
Erlang 19 [...]

Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)
iex(1)> [1, 2, 3, 4, 5]
[1, 2, 3, ...]

सारांश

कार्य

after_spawn()

वापसी के बाद पंजीकृत

after_spawn(fun)

IEx प्रक्रिया को शुरू करने के बाद एक फ़ंक्शन को पंजीकृत करने के लिए पंजीकृत करता है

तोड़! (एस्ट, स्टॉप \\ 1)

IEx.break!/4 लिए मैक्रो-आधारित शॉर्टकट IEx.break!/4

विराम (मॉड्यूल, फ़ंक्शन, धमनी, बंद हो जाता है \\ 1)

stops की दी गई संख्या के साथ module , function और arity में एक ब्रेकपॉइंट सेट करता है

रंग (रंग, स्ट्रिंग)

निर्दिष्ट color का उपयोग करके रिटर्न string बच गए

configuration()

IEx कॉन्फ़िगरेशन लौटाता है

configure(options)

IEx को कॉन्फ़िगर करता है

inspect_opts()

निरीक्षण के लिए उपयोग किए गए विकल्पों को प्राप्त करता है

pry()

प्रक्रिया के वातावरण में स्थित है

started?()

अगर IEx शुरू किया गया था तो true

width()

मुद्रण के लिए IEx चौड़ाई प्राप्त करता है

कार्य

after_spawn ()

वापसी के बाद पंजीकृत।

after_spawn (मज़ा)

IEx प्रक्रिया को शुरू करने के बाद एक फ़ंक्शन को पंजीकृत करने के लिए पंजीकृत करता है।

ब्रेक! (एस्ट, स्टॉप \\ 1) (मैक्रो) (1.5.0 के बाद से)

IEx.break!/4 लिए मैक्रो-आधारित शॉर्टकट IEx.break!/4

ब्रेक (मॉड्यूल, फ़ंक्शन, एरिटी, स्टॉप \\ 1) (1.5.0 के बाद से)

stops की दी गई संख्या के साथ module , function और arity में एक ब्रेकपॉइंट सेट करता है।

यह फ़ंक्शन दिए गए मॉड्यूल को इंस्ट्रूमेंट करेगा और दिए गए फंक्शन और एरिटी में ब्रेकप्वाइंट के साथ मेमोरी में एक नया वर्जन लोड करेगा। यदि मॉड्यूल recompiled है, तो सभी विराम बिंदु खो जाते हैं।

जब एक ब्रेकपॉइंट पहुंच जाता है, तो IEx पूछेगा कि क्या आप दिए गए फ़ंक्शन और आर्टी को पसंद करना चाहते हैं। दूसरे शब्दों में, यह IEx.pry/0 समान काम करता है क्योंकि चल रही प्रक्रिया IEx कमांड का मूल्यांकनकर्ता बन जाती है और अस्थायी रूप से एक कस्टम ग्रुप लीडर के रूप में बदल जाती है। हालाँकि, IEx.pry/0 से अलग, स्रोत कोड से उपनाम और आयात शेल में उपलब्ध नहीं होंगे।

IEx सहायकों में ब्रेकप्वाइंट से संबंधित कई उपयुक्तताएं शामिल हैं। नीचे उन्हें पूर्ण मॉड्यूल के साथ सूचीबद्ध किया गया है, जैसे IEx.Helpers.breaks/0 , लेकिन याद रखें कि इसे IEx के अंदर सीधे breaks() रूप में कहा जा सकता है। वो हैं:

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

वैकल्पिक रूप से, stops तर्क को पास करके stops की संख्या बढ़ाई जा सकती है। IEx.Helpers.reset_break/1 और IEx.Helpers.reset_break/3 का उपयोग शून्य पर वापस संख्या को रीसेट करने के लिए किया जा सकता है। ध्यान दें कि सभी ब्रेकपॉइंट्स पर रोक के बाद भी मॉड्यूल "इंस्ट्रूमेंटेड" बना रहता है। आप किसी दिए गए मॉड्यूल में IEx.Helpers.remove_breaks/1 और IEx.Helpers.remove_breaks/0 कॉल करके सभी मॉड्यूल को कॉल करके इंस्ट्रूमेंटेशन निकाल सकते हैं।

किसी ब्रेकपॉइंट से बाहर निकलने के लिए, डेवलपर या तो continue() , जो अगले ब्रेकपॉइंट के मिलने तक शेल को ब्लॉक कर देगा या प्रक्रिया समाप्त हो जाएगी, या रिस्पॉन्स respawn() आमंत्रित कर सकता है, जो एक नया IEx शेल शुरू करता है, याजक को मुक्त करता है।

यह कार्यक्षमता केवल Elixir कोड पर काम करती है और इसके लिए Erlang / OTP 20+ की आवश्यकता होती है।

उदाहरण

नीचे दिए गए उदाहरण break! का उपयोग करेंगे break! यह मानते हुए कि आप अपने IEx शेल से सीधे ब्रेकपॉइंट सेट कर रहे हैं। लेकिन आप पूरी तरह से योग्य नाम IEx.break! का उपयोग करके कहीं से भी एक ब्रेक सेट कर सकते हैं IEx.break!

निम्नलिखित URI.decode_query/2 पर एक ब्रेकप्वाइंट सेट करता है:

break! URI, :decode_query, 2

यह कॉल एक बार टूटने वाले ब्रेकपॉइंट को सेटअप करेगी। एक ब्रेकपॉइंट सेट करने के लिए जो 10 बार बंद हो जाएगा:

break! URI, :decode_query, 2, 10

IEx.break!/2 एक सुविधा मैक्रो है जो ब्रेकपॉइंट्स को Mod.fun/arity प्रारूप में दिए जाने की अनुमति देता है:

break! URI.decode_query/2

या एक ब्रेकपॉइंट सेट करने के लिए जो 10 बार बंद हो जाएगा:

break! URI.decode_query/2, 10

यह फ़ंक्शन ब्रेकपॉइंट आईडी लौटाता है और ब्रेकपॉइंट स्थापित करने में त्रुटि होने पर उठाएगा।

पैटर्न और गार्ड

IEx.break!/2 पैटर्न देने की अनुमति देता है, केवल कुछ अवसरों में ब्रेकपॉइंट को ट्रिगर करता है। उदाहरण के लिए, केवल पहले तर्क "फू = बार" स्ट्रिंग होने पर ब्रेकपॉइंट को ट्रिगर करने के लिए:

break! URI.decode_query("foo=bar", _)

या जब भी दूसरा तर्क एक से अधिक तत्व वाला नक्शा हो, उसे ट्रिगर करने के लिए:

break! URI.decode_query(_, map) when map_size(map) > 0

प्रति फ़ंक्शन केवल एक ब्रेक बिंदु सेट किया जा सकता है। तो अगर आप IEx.break! कॉल IEx.break! कई बार विभिन्न पैटर्न के साथ, केवल अंतिम पैटर्न रखा जाता है।

ध्यान दें कि, जबकि पैटर्न मैक्रोज़ को दिए जा सकते हैं, याद रखें कि मैक्रोज़ एएसटी को तर्क के रूप में प्राप्त करते हैं, न कि मूल्यों के रूप में। उदाहरण के लिए, यदि आप निम्नलिखित पैटर्न के साथ किसी मैक्रो को तोड़ने का प्रयास करते हैं:

break! MyModule.some_macro(pid) when pid == self()

यह ब्रेकपॉइंट कभी नहीं पहुंचेगा, क्योंकि एक मैक्रो कभी भी पीआईडी ​​प्राप्त नहीं करता है। यहां तक ​​कि अगर आप मैक्रो को MyModule.some_macro(self()) रूप में MyModule.some_macro(self()) , तो मैक्रो एएसटी को self() कॉल का प्रतिनिधित्व करेगा, और पीआईडी ​​को ही नहीं।

ब्रेक और मिक्स टेस्ट

परीक्षण के दौरान IEx.break!/4 उपयोग करने के लिए, आपको iex अंदर मिक्स चलाने की जरूरत है और टाइमआउट में चलने से बचने के लिए mix test को --trace लिए पास पास करें:

iex -S mix test --trace
iex -S mix test path/to/file:line --trace

रंग (रंग, स्ट्रिंग)

निर्दिष्ट color का उपयोग करके रिटर्न string बच गए।

string में एएनएसआई किसी भी तरह से संसाधित नहीं होता है।

विन्यास ()

IEx कॉन्फ़िगरेशन लौटाता है।

कॉन्फ़िगर (विकल्प)

IEx को कॉन्फ़िगर करता है।

समर्थित विकल्प हैं:

  • :colors
  • :inspect
  • :width
  • :history_size
  • :default_prompt
  • :alive_prompt

उन्हें नीचे दिए गए अनुभागों में व्यक्तिगत रूप से चर्चा की जाती है।

रंग की

एक कीवर्ड सूची जो शेल द्वारा उपयोग की जाने वाली सभी रंग सेटिंग्स को एन्क्रिप्ट करती है। समर्थित रंगों और विशेषताओं की सूची के लिए IO.ANSI मॉड्यूल के लिए प्रलेखन देखें।

कीवर्ड सूची में समर्थित कुंजियों की सूची:

  • :enabled - बूलियन मान जो रंग को चालू और बंद करने की अनुमति देता है
  • :eval_result - एक अभिव्यक्ति के परिणामस्वरूप मूल्य के लिए रंग
  • :eval_info - ... विभिन्न सूचना संदेश
  • :eval_error -… त्रुटि संदेश
  • :eval_interrupt - ... संदेशों को बाधित करना
  • :stack_info -… स्टैकट्रेस रंग
  • :blame_diff -… जब बिना किसी मिलान के स्रोत को दोष दिया जाए
  • :ls_directory - ... निर्देशिका प्रविष्टियों के लिए (एलएस सहायक)
  • :ls_device - ... उपकरण प्रविष्टियाँ (ls सहायक)

जब मुद्रण दस्तावेज़, IEx मार्कडाउन दस्तावेज़ को ANSI में भी परिवर्तित करेगा। इसके लिए रंगों को कॉन्फ़िगर किया जा सकता है:

  • :doc_code - कोड ब्लॉक की विशेषताएँ (सियान, उज्ज्वल)
  • :doc_inline_code - इनलाइन कोड (सियान)
  • :doc_headings - h1 और h2 (पीला, चमकीला)
  • :doc_title - आउटपुट के लिए समग्र शीर्षक (उल्टा, पीला, चमकीला)
  • :doc_bold - (उज्ज्वल)
  • :doc_underline - (रेखांकित करें)

IEx भी :syntax_colors विकल्प का उपयोग कर अभिव्यक्तियों का रंग :syntax_colors । इस तरह के साथ अक्षम किया जा सकता है:

IEx.configure [colors: [syntax_colors: false]]

हालाँकि, आप सिंटैक्स रंगों को कॉन्फ़िगर भी कर सकते हैं, हालाँकि:

IEx.configure [colors: [syntax_colors: [atom: :red]]]

अधिकांश अंतर्निहित डेटा प्रकारों के लिए कॉन्फ़िगरेशन का समर्थन किया जाता है:: :atom , :string :binary :list :number :boolean :nil , आदि। डिफ़ॉल्ट है:

[number: :magenta, atom: :cyan, string: :green,
 boolean: :magenta, nil: :magenta]

निरीक्षण

अभिव्यक्ति मूल्यांकन के परिणामों को प्रिंट करते समय शेल द्वारा उपयोग किए जाने वाले निरीक्षण विकल्पों वाली एक कीवर्ड सूची। 50 प्रविष्टियों की सीमा के साथ सुंदर स्वरूपण के लिए डिफ़ॉल्ट।

सभी प्रविष्टियों को दिखाने के लिए, सीमा को कॉन्फ़िगर करें :infinity :

IEx.configure [inspect: [limit: :infinity]]

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

चौड़ाई

आउटपुट में उपयोग करने के लिए स्तंभों की अधिकतम संख्या को इंगित करने वाला पूर्णांक। डिफ़ॉल्ट मान 80 कॉलम है। वास्तविक आउटपुट चौड़ाई इस संख्या और परिणाम का न्यूनतम है :io.columns । इस तरह से आप IEx को अपने सबसे बड़े स्क्रीन आकार के रूप में कॉन्फ़िगर कर सकते हैं और यह हमेशा आपके वर्तमान टर्मिनल स्क्रीन की पूरी चौड़ाई को लेना चाहिए।

इतिहास का आकार

इतिहास में रखने के लिए अभिव्यक्तियों की संख्या और उनके परिणाम। मान एक पूर्णांक है। जब यह नकारात्मक है, तो इतिहास असीमित है।

शीघ्र

यह एक विकल्प है जो इनपुट का इंतजार करते समय उपयोगकर्ता को प्रदर्शित होने वाले संकेत को निर्धारित करता है।

मूल्य एक कीवर्ड सूची है जिसमें दो संभावित कुंजियों का संकेत दिया गया है जो त्वरित प्रकारों का प्रतिनिधित्व करती हैं:

शीघ्र स्ट्रिंग में निम्नलिखित मानों को उचित रूप से प्रतिस्थापित किया जाएगा:

  • %counter - इतिहास का सूचकांक
  • %prefix - IEx.Server द्वारा दिया गया एक उपसर्ग
  • %node - स्थानीय नोड का नाम

inspect_opts ()

निरीक्षण के लिए उपयोग किए गए विकल्पों को प्राप्त करता है।

pry () (मैक्रो)

प्रक्रिया के वातावरण में स्थित है।

किसी विशेष प्रक्रिया द्वारा निष्पादित किए जाने पर कोड के किसी विशेष भाग को डिबग करने के लिए यह उपयोगी है। प्रक्रिया IEx आदेशों का मूल्यांकनकर्ता बन जाती है और अस्थायी रूप से एक कस्टम समूह के नेता के रूप में बदल जाती है। IEx.Helpers.respawn/0 कॉल करके उन मानों को वापस कर दिया जाता है, जो एक नए IEx शेल को शुरू करता है, जो पुजारी को मुक्त करता है।

जब एक प्रक्रिया को पुजारी किया जाता है, तो सभी कोड IEx के अंदर चलता है और मूल कोड से सभी आयात और उपनामों तक पहुंच होती है। हालांकि, कोड का मूल्यांकन किया जाता है और इसलिए मॉड्यूल के निजी कार्यों को पुरोहित नहीं किया जा सकता है। मॉड्यूल कार्यों को अभी भी Mod.fun(args) माध्यम से एक्सेस करने की आवश्यकता है।

वैकल्पिक रूप से, आप किसी दिए गए मॉड्यूल, फ़ंक्शन और एरिटी पर कोई नियंत्रण नहीं होने पर ब्रेकपॉइंट सेटअप करने के लिए IEx.break!/4 का उपयोग कर सकते हैं। जबकि IEx.break!/4 अधिक लचीला है, इसके लिए Erlang / OTP 20+ की आवश्यकता होती है और इसमें स्रोत कोड से आयात और उपनाम के बारे में जानकारी नहीं होती है।

उदाहरण

मान लीजिए कि आप जांचना चाहते हैं कि किसी विशेष कार्य के साथ क्या हो रहा है। फ़ंक्शन से IEx.pry/1 को आमंत्रित करके, IEx आपको इसकी बाइंडिंग (चर) का उपयोग करने, इसकी शाब्दिक जानकारी को सत्यापित करने और प्रक्रिया की जानकारी तक पहुंचने की अनुमति देगा। आइए एक उदाहरण देखें:

import Enum, only: [map: 2]

defmodule Adder do
  def add(a, b) do
    c = a + b
    require IEx; IEx.pry
  end
end

Adder.add(1, 2) लागू करते Adder.add(1, 2) , आपको अपने शेल में दिए गए वातावरण के बारे में Adder.add(1, 2) लिए एक संदेश प्राप्त होगा। इसकी अनुमति देकर, शेल को रीसेट कर दिया जाएगा और आप ऊपर से सभी चर और लेक्सिकल स्कोप तक पहुंच प्राप्त करेंगे:

pry(1)> map([a, b, c], &IO.inspect(&1))
1
2
3

ध्यान रखें कि IEx.pry/1 कॉलर प्रक्रिया में चलता है, मूल्यांकन चक्र के दौरान कॉलर को अवरुद्ध करता है। कॉल करने की प्रक्रिया को रिस्पांस respawn/0 कॉल करके मुक्त किया जा सकता है, जो एक नया IEx मूल्यांकन चक्र शुरू करता है, जिससे यह चलता है:

pry(2)> respawn()
true

Interactive Elixir - press Ctrl+C to exit (type h() ENTER for help)

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

पीरी और मैक्रोज़

मैक्रो द्वारा परिभाषित कोड के अंदर Pry सेट करते समय, जैसे:

defmacro __using__(_) do
  quote do
    def add(a, b) do
      c = a + b
      require IEx; IEx.pry
    end
  end
end

उद्धृत भावों में स्वच्छता तंत्र के कारण quote अंदर परिभाषित चर, prying के दौरान उपलब्ध नहीं होंगे। स्वच्छता तंत्र उद्धृत नामों में परिवर्तनशील नामों को बदलता है ताकि वे मैक्रोज़ के उपयोगकर्ताओं द्वारा परिभाषित चर से न टकराएं। इसलिए मूल नाम उपलब्ध नहीं हैं।

Pry और मिश्रण परीक्षण

परीक्षणों के दौरान IEx.pry/0 उपयोग करने के लिए, आपको iex अंदर मिक्स चलाने की आवश्यकता है और टाइमआउट में चलने से बचने के लिए mix test को --trace लिए - पास करना --trace :

iex -S mix test --trace
iex -S mix test path/to/file:line --trace

शुरू कर दिया है?()

अगर IEx शुरू किया गया था तो true

चौड़ाई()

मुद्रण के लिए IEx चौड़ाई प्राप्त करता है।

सहायकों द्वारा उपयोग किया जाता है और इसमें डिफ़ॉल्ट रूप से अधिकतम 80 वर्णों की टोपी होती है।