Elixir 1.7

IEx.Helpers




elixir

IEx.Helpers

इंटरएक्टिव अमृत में आपका स्वागत है। आप वर्तमान में मॉड्यूल IEx.Helpers लिए प्रलेखन देख रहे हैं, जो कई सहायकों को काम करने के लिए IEx.Helpers के खोल को अधिक खुशहाल बनाने के लिए प्रदान करता है।

यह संदेश सहायक h() को आम तौर पर h/0 रूप में संदर्भित किया जाता है (क्योंकि यह 0 तर्क की अपेक्षा करता है) द्वारा शुरू किया गया था।

आप किसी भी अमृत मॉड्यूल या फ़ंक्शन के लिए दस्तावेज़ीकरण लागू करने के लिए h/1 फ़ंक्शन का उपयोग कर सकते हैं:

iex> h(Enum)
iex> h(Enum.map)
iex> h(Enum.reverse/1)

आप शेल में मौजूद किसी भी मूल्य को आत्मसात करने के लिए i/1 फ़ंक्शन का उपयोग कर सकते हैं:

iex> i("hello")

कई अन्य सहायक उपलब्ध हैं, यहाँ कुछ उदाहरण दिए गए हैं:

  • b/1 - किसी दिए गए मॉड्यूल के लिए कॉलबैक जानकारी और डॉक्स प्रिंट करता है
  • c/1 - एक फ़ाइल संकलित करता है
  • c/2 - एक फ़ाइल संकलित करता है और दिए गए पथ को बायटेकोड लिखता है
  • cd/1 - वर्तमान निर्देशिका को बदलता है
  • clear/0 - स्क्रीन को साफ करता है
  • exports/1 - एक मॉड्यूल में सभी निर्यात (फ़ंक्शन + मैक्रोज़) दिखाता है
  • flush/0 - शेल में भेजे गए सभी संदेशों को flush/0 करता है
  • h/0 - इस मदद संदेश को प्रिंट करता है
  • h/1 - प्रिंट दिए गए मॉड्यूल, फ़ंक्शन या मैक्रो के लिए मदद करता है
  • i/0 - अंतिम मान के बारे में जानकारी प्रिंट करता है
  • i/1 - दिए गए शब्द के बारे में जानकारी प्रिंट करता है
  • ls/0 - वर्तमान निर्देशिका की सामग्री को सूचीबद्ध करता है
  • ls/1 - निर्दिष्ट निर्देशिका की सामग्री को सूचीबद्ध करता है
  • open/1 - आपके एडिटर में दिए गए मॉड्यूल या फ़ंक्शन के लिए स्रोत खोलता है
  • pid/1 - एक स्ट्रिंग से PID बनाता है
  • pid/3 - पास किए गए 3 पूर्णांक तर्कों के साथ एक PID बनाता है
  • ref/1 - एक स्ट्रिंग से एक संदर्भ बनाता है
  • ref/4 - 4 पूर्णांक तर्कों के साथ एक संदर्भ बनाता है
  • pwd/0 - वर्तमान कार्य निर्देशिका को प्रिंट करता है
  • r/1 - दिए गए मॉड्यूल के स्रोत फ़ाइल को recompiles
  • recompile/0 - वर्तमान प्रोजेक्ट को recompiles करता है
  • runtime_info/0 - रनटाइम जानकारी प्रिंट करता है (संस्करण, मेमोरी उपयोग, आँकड़े)
  • v/0 - इतिहास से अंतिम मान प्राप्त करता है
  • v/1 - इतिहास से nth मान प्राप्त करता है

उन सभी कार्यों के लिए सहायता h/1 हेल्पर का उपयोग करके सीधे कमांड लाइन से ली जा सकती है। प्रयत्न:

iex> h(v/0)

उपलब्ध सभी IEx सहायकों को सूचीबद्ध करने के लिए, जो IEx.Helpers मॉड्यूल में प्रभावी रूप से सभी निर्यात (फ़ंक्शन और मैक्रोज़) हैं:

iex> exports(IEx.Helpers)

इस मॉड्यूल में डीबगिंग उद्देश्यों के लिए सहायक भी शामिल हैं, अधिक जानकारी के लिए IEx.break!/4 देखें।

एक पूरे के रूप में IEx के बारे में अधिक जानने के लिए, टाइप करें h(IEx)

सारांश

कार्य

b/1

दिए गए कॉलबैक फ़ंक्शन के लिए दस्तावेज़ प्रिंट करता है

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

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

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

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

breaks()

सभी ब्रेकपॉइंट्स को टर्मिनल पर प्रिंट करता है

c/2

दी गई फाइलों को संकलित करता है

cd/1

वर्तमान कार्य निर्देशिका को दिए गए पथ में परिवर्तित करता है

clear/0

कंसोल स्क्रीन को साफ़ करता है

continue()

वर्तमान प्रक्रिया के निष्पादन को जारी रखता है

exports/1

दिए गए मॉड्यूल द्वारा निर्यात किए गए सभी कार्यों और मैक्रो की एक सूची प्रिंट करता है

flush/0

शेल के इनबॉक्स में भेजे गए सभी संदेशों को निकालता है और उन्हें प्रिंट करता है

h/0

IEx.Helpers लिए दस्तावेज़ प्रिंट करता है

h/1

दिए गए मॉड्यूल या दिए गए फ़ंक्शन / एरिटी जोड़ी के लिए प्रलेखन प्रिंट करता है

i/1

किसी भी शब्द के डेटा प्रकार के बारे में जानकारी प्रिंट करता है

import_file(path)

path पर फ़ाइल की सामग्री का मूल्यांकन करता है जैसे कि इसे सीधे शेल में टाइप किया गया था

import_file_if_available(path)

import_file समान लेकिन केवल फ़ाइल उपलब्ध होने पर इसे आयात करता है

import_if_available (उद्धृत_module, opts \\ [])

दिए गए तर्कों के साथ import/2 को कॉल करता है, लेकिन केवल अगर मॉड्यूल उपलब्ध है

l(module)

दिए गए मॉड्यूल के BEAM कोड को लोड करता है (और यह सुनिश्चित करता है कि पिछले किसी पुराने संस्करण को पहले ठीक से शुद्ध किया गया था)

ls/1

दिए गए निर्देशिका की सामग्री की एक सूची प्रिंट करता है

nl (नोड्स \\ Node.list (), मॉड्यूल)

नोड्स की सूची में दिए गए मॉड्यूल के BEAM कोड को दर्शाता है

open()

वर्तमान prying स्थान खोलता है

open/1

दिए गए मॉड्यूल, मॉड्यूल / फ़ंक्शन / एरिटी या {file, line} खोलता है

pid/1

string से एक पीआईडी ​​बनाता है

pid/3

फ़ंक्शन के तर्कों के रूप में पारित किए गए 3 गैर-नकारात्मक पूर्णांक के साथ एक पीआईडी ​​बनाता है

pwd/0

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

r/1

दिए गए module पुनः साझा करता है और पुनः लोड करता है

recompile (विकल्प \\ [])

वर्तमान मिक्स एप्लिकेशन को पुनः साझा करता है

ref/1

string से एक संदर्भ बनाता है

ref/4
remove_breaks()

सभी मॉड्यूल से सभी ब्रेकपॉइंट और इंस्ट्रूमेंटेशन निकालता है

remove_breaks(module)

module से सभी ब्रेकप्वाइंट और इंस्ट्रूमेंटेशन निकालता है

reset_break(id)

दिए गए आईडी के साथ ब्रेकपॉइंट में लंबित स्टॉप की संख्या को शून्य पर सेट करता है

रीसेट_ब्रेक (मॉड्यूल, फ़ंक्शन, एरिटी)

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

respawn()

एक नई शेल प्रक्रिया शुरू करके वर्तमान शेल का जवाब देता है

runtime_info/0

प्रिंट्स vm / रनटाइम जानकारी जैसे कि संस्करण, मेमोरी उपयोग और आँकड़े। अतिरिक्त विषय runtime_info/1 माध्यम से उपलब्ध हैं

runtime_info/1

जैसे runtime_info/0 , विषय या विषयों की सूची को छोड़कर। उदाहरण विषय :applications आवेदन लोड किए गए :applications को सूचीबद्ध करेंगे

t(term)

दिए गए मॉड्यूल के लिए या दिए गए फ़ंक्शन / एरिटी जोड़ी के लिए प्रकार प्रिंट करता है

use_if_available (quot_module, opts \\ [])

कॉल दिए गए तर्कों के साथ use/2 , लेकिन केवल अगर मॉड्यूल उपलब्ध है

v/1

इतिहास में n वें अभिव्यक्ति का मूल्य लौटाता है

व्हेरेमी (त्रिज्या \\ 2)

एक pry सत्र में वर्तमान स्थान और स्टैकट्रेस प्रिंट करता है

कार्य

b (टर्म) (मैक्रो)

दिए गए कॉलबैक फ़ंक्शन के लिए दस्तावेज़ प्रिंट करता है।

यह सभी उपलब्ध व्यवहार कॉलबैक को सूचीबद्ध करने के लिए एकल मॉड्यूल तर्क को भी स्वीकार करता है।

उदाहरण

iex> b(Mix.Task.run/1)
iex> b(Mix.Task.run)
iex> b(GenServer)

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

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

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

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

IEx.break!/4 में ब्रेकपॉइंट के पूर्ण विवरण के लिए IEx.break!/4 देखें।

विराम () (1.5.0 से)

सभी ब्रेकपॉइंट्स को टर्मिनल पर प्रिंट करता है।

सी (फाइलें, पथ \\: in_memory)

दी गई फाइलों को संकलित करता है।

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

यह संकलित मॉड्यूल के नाम लौटाता है।

यदि आप किसी मौजूदा मॉड्यूल को फिर से जोड़ना चाहते हैं, तो इसके बजाय r/1 जांच करें।

उदाहरण

iex> c(["foo.ex", "bar.ex"], "ebin")
[Foo, Bar]

iex> c("baz.ex")
[Baz]

सीडी (निर्देशिका)

वर्तमान कार्य निर्देशिका को दिए गए पथ में परिवर्तित करता है।

स्पष्ट()

कंसोल स्क्रीन को साफ़ करता है।

यह फ़ंक्शन केवल तभी काम करता है यदि शेल पर ANSI एस्केप कोड सक्षम हैं, जिसका अर्थ है कि यह फ़ंक्शन विंडोज मशीनों पर डिफ़ॉल्ट रूप से अनुपलब्ध है।

जारी रखें () (1.5.0 के बाद से)

वर्तमान प्रक्रिया के निष्पादन को जारी रखता है।

यह आमतौर पर IEx.pry/0 या IEx.break!/4 साथ शुरू होने वाले सत्रों द्वारा बुलाया जाता है। यह वर्तमान प्रक्रिया को अगले ब्रेकपॉइंट तक निष्पादित करने की अनुमति देता है, जो स्वचालित रूप से आईईएक्स को वापस करने की अनुमति के बिना नियंत्रण वापस प्राप्त करेगा।

यदि चल रही प्रक्रिया समाप्त हो जाती है, तो एक नया IEx सत्र शुरू किया जाता है।

जबकि प्रक्रिया निष्पादित होती है, उपयोगकर्ता के पास शेल का नियंत्रण नहीं होगा। यदि आप एक नया शेल शुरू करना चाहते हैं, तो इसके बजाय respawn() उपयोग करें।

निर्यात (मॉड्यूल \\ कर्नेल) (1.5.0 के बाद से)

दिए गए मॉड्यूल द्वारा निर्यात किए गए सभी कार्यों और मैक्रो की एक सूची प्रिंट करता है।

फ्लश ()

शेल के इनबॉक्स में भेजे गए सभी संदेशों को निकालता है और उन्हें प्रिंट करता है।

ज ()

IEx.Helpers लिए दस्तावेज़ प्रिंट करता है।

एच (अवधि) (मैक्रो)

दिए गए मॉड्यूल या दिए गए फ़ंक्शन / एरिटी जोड़ी के लिए प्रलेखन प्रिंट करता है।

उदाहरण

iex> h(Enum)

उदाहरण के लिए, यह module.fun/arity fun/arity module.fun/arity और module.fun/arity fun/arity में कार्यों को भी स्वीकार करता है:

iex> h(receive/1)
iex> h(Enum.all?/2)
iex> h(Enum.all?)

मैं (शब्द \\ v (-1))

किसी भी शब्द के डेटा प्रकार के बारे में जानकारी प्रिंट करता है।

यदि कोई तर्क नहीं दिया जाता है, तो पिछले अभिव्यक्ति के मूल्य का उपयोग किया जाता है।

उदाहरण

iex> i(1..5)

प्रिंट होगा:

Term
  1..5
Data type
  Range
Description
  This is a struct. Structs are maps with a __struct__ key.
Reference modules
  Range, Map

import_file (पथ) (मैक्रो) (1.4.0 के बाद से)

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

path को शाब्दिक स्ट्रिंग होना चाहिए। path स्वचालित रूप से Path.expand/1 माध्यम से विस्तारित होता है।

उदाहरण

# ~/file.exs
value = 13

# in the shell
iex(1)> import_file "~/file.exs"
13
iex(2)> value
13

import_file_if_available (पथ) (मैक्रो)

import_file समान लेकिन केवल फ़ाइल उपलब्ध होने पर इसे आयात करता है।

डिफ़ॉल्ट रूप से, import_file(path) विफल रहता है जब दी गई फ़ाइल मौजूद नहीं है। हालाँकि, चूंकि compile-time में import_file(path) का विस्तार किया गया है, इसलिए मैक्रो हमेशा विस्तारित होने के बाद फ़ाइल को सशर्त आयात करना संभव नहीं है:

# This raises a File.Error if ~/.iex.exs doesn't exist.
if ("~/.iex.exs" |> Path.expand |> File.exists?) do
  import_file "~/.iex.exs"
end

यह मैक्रो इस समस्या की जाँच करता है कि फ़ाइल मौजूद है या नहीं।

import_if_available (उद्धृत_module, opts \\ []) (मैक्रो)

दिए गए तर्कों के साथ import/2 को कॉल करता है, लेकिन केवल अगर मॉड्यूल उपलब्ध है।

यह आपको .iex.exs फ़ाइलों ( ~/.iex.exs सहित) को संकलित त्रुटियों के बिना आयात करने देता है यदि आप एक कंसोल खोलते हैं जहां मॉड्यूल उपलब्ध नहीं है।

उदाहरण

# In ~/.iex.exs
import_if_available Ecto.Query

एल (मॉड्यूल)

दिए गए मॉड्यूल के BEAM कोड को लोड करता है (और यह सुनिश्चित करता है कि किसी भी पिछले पुराने संस्करण को पहले ठीक से शुद्ध किया गया था)।

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

ls (पथ \\ ")"

दिए गए निर्देशिका की सामग्री की एक सूची प्रिंट करता है।

यदि path किसी फ़ाइल को इंगित करता है, तो उसका पूर्ण पथ प्रिंट करता है।

nl (नोड्स \\ Node.list (), मॉड्यूल)

नोड्स की सूची में दिए गए मॉड्यूल के BEAM कोड को दर्शाता है।

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

नोड सूची सभी जुड़े नोड्स की एक सूची को डिफॉल्ट करती है।

रिटर्न {:error, :nofile} यदि मॉड्यूल के लिए ऑब्जेक्ट कोड (यानी ".beam" फ़ाइल) स्थानीय रूप से नहीं मिल सका।

उदाहरण

iex> nl(HelloWorld)
{:ok, [{:[email protected], :loaded, HelloWorld},
       {:[email protected], :loaded, HelloWorld}]}

iex> nl(NoSuchModuleExists)
{:error, :nofile}

खुला()

वर्तमान prying स्थान खोलता है।

यह कमांड केवल IEx.pry/0 माध्यम से मैन्युअल रूप से शुरू किए गए एक pry सत्र के अंदर काम करता है या IEx.pry/0 IEx.break!/4 माध्यम से एक ब्रेकप्वाइंट सेट किया गया है। एक नियमित IEx सत्र के दौरान इस फ़ंक्शन को कॉल करना एक त्रुटि प्रिंट करेगा।

ध्यान रखें कि open() स्थान मौजूद नहीं हो सकता है जब प्रीक्लेम्ड स्रोत कोड, जैसे कि एलिक्सिर।

अधिक जानकारी के लिए और किसी भी मॉड्यूल या फ़ंक्शन को खोलने के लिए, open/1

खुला (शब्द) (मैक्रो)

दिए गए मॉड्यूल, मॉड्यूल / फ़ंक्शन / एरिटी या {file, line} खोलता है।

यह फ़ंक्शन ELIXIR_EDITOR पर्यावरण चर का उपयोग करता है और पूर्व उपलब्ध न होने पर EDITOR वापस आ जाता है।

डिफ़ॉल्ट रूप से, यह फ़ाइल को खोलने का प्रयास करता है और फ़ाइल का उपयोग करके file:line नोटेशन। उदाहरण के लिए, यदि आपके संपादक को subl कहा जाता है, तो यह फाइल को इस प्रकार खोलेगा:

subl path/to/file:line

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

कस्टम संपादकों को __FILE__ और __LINE__ नोटेशन का उपयोग करके समर्थित किया __LINE__ है, उदाहरण के लिए:

ELIXIR_EDITOR="my_editor +__LINE__ __FILE__"

और अमृत ठीक से मूल्यों को प्रक्षेपित करेगा।

चूंकि यह फ़ंक्शन संपादक द्वारा दिए गए परिणाम को प्रिंट करता है, ELIXIR_EDITOR को "इको" सेट किया जा सकता है यदि आप इसे खोलने के बजाय स्थान प्रदर्शित करना चाहते हैं।

ध्यान रखें कि प्री-कनेक्टेड सोर्स कोड खोलते समय स्थान मौजूद नहीं हो सकता है।

उदाहरण

iex> open(MyApp)
iex> open(MyApp.fun/2)
iex> open({"path/to/file", 1})

पीआईडी (स्ट्रिंग)

string से एक पीआईडी ​​बनाता है।

उदाहरण

iex> pid("0.21.32")
#PID<0.21.32>

पिड (x, y, z)

फ़ंक्शन के तर्कों के रूप में पारित किए गए 3 गैर-नकारात्मक पूर्णांक के साथ एक पीआईडी ​​बनाता है।

उदाहरण

iex> pid(0, 21, 32)
#PID<0.21.32>
iex> pid(0, 64, 2048)
#PID<0.64.2048>

लोक निर्माण विभाग ()

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

आर (मॉड्यूल)

दिए गए module पुनः साझा करता है और पुनः लोड करता है।

कृपया ध्यान दें कि मॉड्यूल के रूप में एक ही फाइल में परिभाषित सभी module को फिर से जोड़ा और पुनः लोड किया गया है।

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

इन-मेमोरी रीलोडिंग

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

चूंकि टाइपसेप्स और डॉक्स को .बीम फाइल से लोड किया जाता है (वे मॉड्यूल के साथ मेमोरी में लोड नहीं होते हैं क्योंकि उन्हें मेमोरी में रहने की कोई आवश्यकता नहीं है), जब आप मॉड्यूल को लोड करते हैं तो वे फिर से लोड नहीं होते हैं।

recompile (विकल्प \\ [])

वर्तमान मिक्स एप्लिकेशन को पुनः साझा करता है।

यह सहायक केवल तभी काम करता है जब IEx को मिक्स प्रोजेक्ट के साथ शुरू किया जाता है, उदाहरण के लिए, iex -S mix । संकलन के बाद आवेदन को फिर से शुरू नहीं किया जाता है, जिसका अर्थ है कि कोई भी लंबी चलने वाली प्रक्रिया दुर्घटनाग्रस्त हो सकती है क्योंकि किसी भी परिवर्तित मॉड्यूल को अस्थायी रूप से हटा दिया जाएगा और पुन: व्यवस्थित किया जाएगा, बिना उचित कोड परिवर्तन कॉलबैक के।

यदि आप किसी एकल मॉड्यूल को पुनः लोड करना चाहते हैं, तो इसके बजाय r(ModuleName) का उपयोग करने पर विचार करें।

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

विकल्प

  • :force - जब true होता true , तो एप्लिकेशन को फिर से शुरू करने के लिए मजबूर करता है

रेफरी (स्ट्रिंग) (1.6.0 के बाद से)

string से एक संदर्भ बनाता है।

उदाहरण

iex> ref("0.21.32.43")
#Reference<0.21.32.43>

रेफरी (w, x, y, z) (1.6.0 से)

remove_breaks () (1.5.0 के बाद से)

सभी मॉड्यूल से सभी ब्रेकपॉइंट और इंस्ट्रूमेंटेशन निकालता है।

remove_breaks (मॉड्यूल) (1.5.0 के बाद से)

module से सभी ब्रेकप्वाइंट और इंस्ट्रूमेंटेशन निकालता है।

रीसेट_ब्रेक (आईडी) (1.5.0 से)

दिए गए आईडी के साथ ब्रेकपॉइंट में लंबित स्टॉप की संख्या को शून्य पर सेट करता है।

रिटर्न :ok अगर ऐसी ब्रेकपॉइंट आईडी है। :not_found अन्यथा।

ध्यान दें कि रीसेट पर मॉड्यूल "इंस्ट्रूमेंटेड" रहता है। यदि आप किसी मॉड्यूल से सभी ब्रेकपॉइंट और इंस्ट्रूमेंटेशन कोड को प्रभावी ढंग से निकालना चाहते हैं, तो इसके बजाय remove_breaks(module) उपयोग करें।

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

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

यदि मॉड्यूल इंस्ट्रूमेंट नहीं है या यदि दिए गए फ़ंक्शन में ब्रेकपॉइंट नहीं है, तो यह एक नो-ऑप है और यह वापस आता है :not_found । अन्यथा यह लौटता है :ok

ध्यान दें कि रीसेट पर मॉड्यूल "इंस्ट्रूमेंटेड" रहता है। यदि आप किसी मॉड्यूल से सभी ब्रेकपॉइंट और इंस्ट्रूमेंटेशन कोड को प्रभावी ढंग से निकालना चाहते हैं, तो इसके बजाय remove_breaks(module) उपयोग करें।

respawn ()

एक नई शेल प्रक्रिया शुरू करके वर्तमान शेल का जवाब देता है।

runtime_info () (1.5.0 के बाद से)

प्रिंट्स vm / रनटाइम जानकारी जैसे कि संस्करण, मेमोरी उपयोग और आँकड़े। अतिरिक्त विषय runtime_info/1 माध्यम से उपलब्ध हैं।

runtime_info (विषय)

जैसे runtime_info/0 , विषय या विषयों की सूची को छोड़कर। उदाहरण विषय :applications आवेदन लोड किए गए :applications को सूचीबद्ध करेंगे।

t (टर्म) (मैक्रो)

दिए गए मॉड्यूल के लिए या दिए गए फ़ंक्शन / एरिटी जोड़ी के लिए प्रकार प्रिंट करता है।

उदाहरण

iex> t(Enum)
@type t() :: Enumerable.t()
@type acc() :: any()
@type element() :: any()
@type index() :: integer()
@type default() :: any()

iex> t(Enum.t/0)
@type t() :: Enumerable.t()

iex> t(Enum.t)
@type t() :: Enumerable.t()

use_if_available (quoted_module, opts \\ []) (मैक्रो) (1.7.0 से)

कॉल दिए गए तर्कों के साथ use/2 , लेकिन केवल अगर मॉड्यूल उपलब्ध है।

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

उदाहरण

# In ~/.iex.exs
use_if_available Phoenix.HTML

v (n \\ -1)

इतिहास में n वें अभिव्यक्ति का मूल्य लौटाता है।

n एक ऋणात्मक मान हो सकता है: यदि यह है, तो वर्तमान के सापेक्ष संबंधित अभिव्यक्ति मान लौटाया जाता है। उदाहरण के लिए, v(-2) अंतिम मूल्यांकित अभिव्यक्ति से पहले मूल्यांकित अभिव्यक्ति का मान लौटाता है। विशेष रूप से, v(-1) अंतिम मूल्यांकित अभिव्यक्ति का परिणाम देता है और v() वही करता है।

उदाहरण

iex(1)> "hello" <> " world"
"hello world"
iex(2)> 40 + 2
42
iex(3)> v(-2)
"hello world"
iex(4)> v(2)
42
iex(5)> v()
42

व्हेरेमी (त्रिज्या \\ 2) (1.5.0 के बाद से)

एक pry सत्र में वर्तमान स्थान और स्टैकट्रेस प्रिंट करता है।

यह एक radius उम्मीद करता radius जो चुनती है कि वर्तमान रेखा से पहले और बाद में हमें कितनी लाइनें प्रिंट करनी चाहिए। डिफ़ॉल्ट रूप से radius दो लाइनों की होती है:

Location: lib/iex/lib/iex/helpers.ex:79

77:
78:   def recompile do
79:     require IEx; IEx.pry
80:     if mix_started?() do
81:       config = Mix.Project.config

(IEx.Helpers) lib/iex/lib/iex/helpers.ex:78: IEx.Helpers.recompile/0

यह कमांड केवल IEx.pry/0 माध्यम से मैन्युअल रूप से शुरू किए गए एक pry सत्र के अंदर काम करता है या IEx.pry/0 IEx.break!/4 माध्यम से एक ब्रेकप्वाइंट सेट किया गया है। एक नियमित IEx सत्र के दौरान इस फ़ंक्शन को कॉल करना एक त्रुटि प्रिंट करेगा।

ध्यान रखें कि whereami/1 स्थान मौजूद नहीं हो सकता है जब whereami/1 सोर्स कोड, जैसे कि whereami/1