Elixir 1.7

Code




elixir

Code

कोड संकलन, कोड मूल्यांकन और कोड लोडिंग के प्रबंधन के लिए उपयोगिताएँ।

यह मॉड्यूल Erlang का :code व्यवहार को जोड़ने के लिए :code मॉड्यूल को पूरक करता है जो कि अमृत के लिए विशिष्ट है। इस मॉड्यूल के लगभग सभी कार्यों में अमृत के व्यवहार के वैश्विक दुष्प्रभाव हैं।

फाइलों के साथ काम करना

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

  • require_file/2 - एक फ़ाइल संकलित करता है और उसका नाम ट्रैक करता है। यदि यह पहले से आवश्यक हो तो यह फ़ाइल को फिर से संकलित नहीं करता है।

  • compile_file/2 - किसी फ़ाइल को उसके नाम को ट्रैक किए बिना संकलित करता है। फ़ाइल को कई बार संकलित करने पर कई बार संकलित किया जाता है।

  • eval_file/2 - अपने नाम को ट्रैक किए बिना फ़ाइल सामग्री का मूल्यांकन करता है। यह फ़ाइल में अंतिम अभिव्यक्ति का परिणाम देता है, इसके बजाय इसमें परिभाषित मॉड्यूल हैं।

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

जब आप ट्रैकिंग के बिना किसी फ़ाइल में परिभाषित मॉड्यूल में रुचि रखते हैं, तो compile_file/2 का उपयोग किया जाना चाहिए। eval_file/2 का उपयोग तब किया जाना चाहिए जब आप उस मॉड्यूल को परिभाषित करने के बजाय फ़ाइल के मूल्यांकन के परिणाम पर eval_file/2

सारांश

कार्य

append_path(path)

Erlang VM कोड पथ सूची के अंत में एक पथ भेजता है

available_compiler_options()

उपलब्ध संकलक विकल्पों के साथ एक सूची देता है

compile_file/2

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

compile_quoted (उद्धृत, फ़ाइल \\ "nofile")

उद्धृत अभिव्यक्ति संकलित करता है

compile_string (स्ट्रिंग, फ़ाइल \\ "nofile")

दिए गए स्ट्रिंग को संकलित करता है

compiler_options()

कोड सर्वर से संकलन विकल्प प्राप्त करता है

compiler_options(opts)

संकलन विकल्प सेट करता है

delete_path(path)

Erlang VM कोड पथ सूची से एक पथ हटाता है। यह मॉड्यूल कोड खोजने के लिए Erlang VM उपयोगों की निर्देशिकाओं की सूची है

ensure_compiled(module)

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

ensure_compiled?(module)

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

ensure_loaded(module)

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

ensure_loaded?(module)

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

eval_file/2

दी गई फ़ाइल का मूल्यांकन करता है

eval_quoted (उद्धृत, बाइंडिंग \\ [], opts \\ [])

उद्धृत सामग्री का मूल्यांकन करता है

eval_string (स्ट्रिंग, बाइंडिंग \\ [], opts \\ [])

string द्वारा दी गई सामग्री का मूल्यांकन करता है

fetch_docs(module)

दिए गए मॉड्यूल के लिए डॉक्स लौटाता है

format_file! (फ़ाइल, opts \\ [])

एक फ़ाइल को प्रारूपित करता है

format_string! (स्ट्रिंग, opts \\ [])

दिए गए कोड string

get_docs (मॉड्यूल, तरह) को हटा दिया गया

पुराने प्रलेखन प्रारूप को पुनः प्राप्त करने के लिए पदावनत समारोह

prepend_path(path)

Erlang VM कोड पथ सूची की शुरुआत के लिए एक पथ प्रस्तुत करता है

purge_compiler_modules()

पर्ज कंपाइलर मॉड्यूल

require_file/2

दी गई file

required_files()

सभी आवश्यक फ़ाइलों को सूचीबद्ध करता है

string_to_quoted! (string, opts \\ [])

दिए गए स्ट्रिंग को उसके उद्धृत रूप में परिवर्तित करता है

string_to_quoted (स्ट्रिंग, opts \\ [])

दिए गए स्ट्रिंग को उसके उद्धृत रूप में परिवर्तित करता है

unrequire_files(files)

आवश्यक फ़ाइलों की सूची से फ़ाइलें निकालता है

कार्य

append_path (पथ)

append_path(Path.t()) :: true | {:error, :bad_directory}

Erlang VM कोड पथ सूची के अंत में एक पथ भेजता है।

यह मॉड्यूल कोड खोजने के लिए Erlang VM उपयोगों की निर्देशिकाओं की सूची है।

पथ का विस्तार किया जा रहा से पहले Path.expand/1 साथ किया जाता है। यदि यह पथ मौजूद नहीं है, तो एक त्रुटि वापस आ जाती है।

उदाहरण

Code.append_path(".")
#=> true

Code.append_path("/does_not_exist")
#=> {:error, :bad_directory}

available_compiler_options ()

available_compiler_options() :: [atom()]

उपलब्ध संकलक विकल्पों के साथ एक सूची देता है।

अधिक जानकारी के लिए compiler_options(opts) देखें।

उदाहरण

iex> Code.available_compiler_options()
[:docs, :debug_info, :ignore_module_conflict, :relative_paths, :warnings_as_errors]

compile_file (फ़ाइल, रिश्तेदार_to \\ nil)

compile_file(binary(), nil | binary()) :: [{module(), binary()}]

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

जहाँ फ़ाइल स्थित है यह बताने के लिए एक तर्क के रूप में सापेक्ष_को स्वीकार करता है।

ट्यूपल्स की सूची लौटाता है जहां पहला तत्व मॉड्यूल का नाम है और दूसरा इसका बायटेकोड (बाइनरी के रूप में) है। require_file/2 विपरीत, यह संकलित फ़ाइल के फ़ाइलनाम को ट्रैक नहीं करता है।

यदि आप इसमें परिभाषित मॉड्यूल के बजाय फ़ाइल के मूल्यांकन का परिणाम प्राप्त करना चाहते हैं, तो eval_file/2

कई फ़ाइलों को समवर्ती रूप से संकलित करने के लिए, Kernel.ParallelCompiler.compile/2 देखें। Kernel.ParallelCompiler.compile/2

compile_quoted (उद्धृत, फ़ाइल \\ "nofile")

compile_quoted(Macro.t(), binary()) :: [{module(), binary()}]

उद्धृत अभिव्यक्ति संकलित करता है।

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

compile_string (स्ट्रिंग, फ़ाइल \\ "nofile")

compile_string(List.Chars.t(), binary()) :: [{module(), binary()}]

दिए गए स्ट्रिंग को संकलित करता है।

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

चेतावनी : string कोई भी अमृत कोड हो सकता है और कोड को एर्लैंग वीएम के समान विशेषाधिकार के साथ निष्पादित किया जा सकता है: इसका मतलब है कि इस तरह के कोड मशीन से समझौता कर सकते हैं (उदाहरण के लिए सिस्टम कमांड निष्पादित करके)। compile_string/2 इनपुट (जैसे नेटवर्क से आने वाले तार) के साथ compile_string/2 उपयोग न करें।

compiler_options ()

compiler_options() :: %{optional(atom()) => boolean()}

कोड सर्वर से संकलन विकल्प प्राप्त करता है।

अधिक जानकारी के लिए compiler_options(opts) जाँच करें।

उदाहरण

Code.compiler_options()
#=> %{debug_info: true, docs: true,
#=>   warnings_as_errors: false, ignore_module_conflict: false}

compiler_options (opts)

compiler_options(Enumerable.t()) :: %{optional(atom()) => boolean()}

संकलन विकल्प सेट करता है।

ये विकल्प वैश्विक हैं क्योंकि ये एलिक्सिर के कोड सर्वर द्वारा संग्रहीत हैं।

उपलब्ध विकल्प हैं:

  • :docs - जब true , संकलित मॉड्यूल में प्रलेखन को बनाए रखें। true अवहेलना।

  • :debug_info - जब true , संकलित मॉड्यूल में डिबग जानकारी को बनाए रखें। यह एक डेवलपर को मूल स्रोत कोड को फिर से संगठित करने की अनुमति देता है। false अवहेलना करता false

  • :ignore_module_conflict - जब true , ओवरराइड मॉड्यूल जो पहले से ही त्रुटियों को उठाए बिना परिभाषित किए गए थे। false अवहेलना।

  • :relative_paths - जब true , संकलक द्वारा उत्पन्न उद्धृत नोड्स, चेतावनियों और त्रुटियों में सापेक्ष पथ का उपयोग करें। ध्यान दें कि इस विकल्प को अक्षम करने से रनटाइम चेतावनियाँ और त्रुटियाँ प्रभावित नहीं होंगी। true अवहेलना।

  • :warnings_as_errors उत्पन्न होने पर :warnings_as_errors - असफल होने का कारण बनती हैं। false अवहेलना।

यह संकलक विकल्पों का नया मानचित्र लौटाता है।

उदाहरण

Code.compiler_options(debug_info: true)
#=> %{debug_info: true, docs: true,
#=>   warnings_as_errors: false, ignore_module_conflict: false}

delete_path (पथ)

delete_path(Path.t()) :: boolean()

Erlang VM कोड पथ सूची से एक पथ हटाता है। यह मॉड्यूल कोड खोजने के लिए Erlang VM उपयोगों की निर्देशिकाओं की सूची है।

हटाए जाने से पहले पथ का विस्तार किया जाता है। यदि पथ मौजूद नहीं है, तो यह फ़ंक्शन false

उदाहरण

Code.prepend_path(".")
Code.delete_path(".")
#=> true

Code.delete_path("/does_not_exist")
#=> false

ensure_compiled (मॉड्यूल)

ensure_compiled(module()) ::
  {:module, module()}
  | {:error, :embedded | :badfile | :nofile | :on_load_failure}

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

यदि मॉड्यूल पहले से लोड है, तो यह नो-ऑप के रूप में काम करता है। यदि मॉड्यूल अभी तक लोड नहीं किया गया था, तो यह जांचता है कि क्या इसे पहले संकलित करने की आवश्यकता है और फिर इसे लोड करने का प्रयास करता है।

यदि यह मॉड्यूल को लोड करने में सफल होता है, तो यह {:module, module} लौटाता है। यदि नहीं, तो त्रुटि के कारण {:error, reason} लौटाता है।

मॉड्यूल लोडिंग के बारे में अधिक जानकारी के लिए ensure_loaded(module) जांच करें और जब सुनिश्चित करें कि ensure_loaded(module) या ensure_compiled(module) का उपयोग करें

ensure_compiled? (मॉड्यूल)

ensure_compiled?(module()) :: boolean()

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

यह ensure_compiled(module) करने के लिए समान है कि ensure_compiled(module) , लेकिन यह true है कि मॉड्यूल पहले से लोड है या सफलतापूर्वक लोड और संकलित है। अन्यथा false लौटते हैं।

ensure_loaded (मॉड्यूल)

ensure_loaded(module()) ::
  {:module, module()}
  | {:error, :embedded | :badfile | :nofile | :on_load_failure}

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

यदि मॉड्यूल पहले से लोड है, तो यह नो-ऑप के रूप में काम करता है। यदि मॉड्यूल अभी तक लोड नहीं किया गया था, तो वह इसे लोड करने का प्रयास करता है।

यदि यह मॉड्यूल को लोड करने में सफल होता है, तो यह {:module, module} लौटाता है। यदि नहीं, तो त्रुटि के कारण {:error, reason} लौटाता है।

Erlang VM पर कोड लोड हो रहा है

Erlang में कोड लोड करने के लिए दो मोड हैं: इंटरैक्टिव और एम्बेडेड।

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

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

ensure_compiled(module)

Elixir में एक ensure_compiled(module) फ़ंक्शन होता है जो ensure_compiled(module) सुपरसेट होता है।

चूंकि अमृत का संकलन समानांतर में होता है, कुछ स्थितियों में आपको एक मॉड्यूल का उपयोग करने की आवश्यकता हो सकती है जो अभी तक संकलित नहीं थी, इसलिए इसे लोड भी नहीं किया जा सकता है।

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

यह सुनिश्चित करता है कि निर्भरताएँ संकलित की जानी चाहिए।

ज्यादातर मामलों में, ensure_loaded(module) पर्याप्त है। ensure_compiled(module) कि आमतौर पर मैक्रोज़ को शामिल करने के लिए दुर्लभ मामलों में इस्तेमाल किया जाना चाहिए, जिसमें कॉलबैक जानकारी के लिए एक मॉड्यूल को शामिल करना होगा।

उदाहरण

iex> Code.ensure_loaded(Atom)
{:module, Atom}

iex> Code.ensure_loaded(DoesNotExist)
{:error, :nofile}

ensure_loaded? (मॉड्यूल)

ensure_loaded?(module()) :: boolean()

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

सुनिश्चित करने के लिए इसी ensure_loaded(module) , लेकिन यह true है कि मॉड्यूल पहले से लोड है या सफलतापूर्वक लोड किया गया था। अन्यथा false लौटते हैं।

उदाहरण

iex> Code.ensure_loaded?(Atom)
true

eval_file (फ़ाइल, रिश्तेदार_to \\ nil)

eval_file(binary(), nil | binary()) :: {term(), binding :: list()}

दी गई फ़ाइल का मूल्यांकन करता है।

जहाँ फ़ाइल स्थित है यह बताने के लिए एक तर्क के रूप में सापेक्ष_को स्वीकार करता है।

जबकि आवश्यकता होती eval_file/2 require_file/2 और compile_file/2 लोड किए गए मॉड्यूल और उनके बाइटकोड को वापस करता है, eval_file/2 केवल फ़ाइल सामग्री का मूल्यांकन करता है और मूल्यांकन परिणाम और उसके बाइंडिंग (बिल्कुल eval_string/3 रूप में एक ही वापसी मान) को eval_string/3

eval_quoted (उद्धृत, बाइंडिंग \\ [], opts \\ [])

eval_quoted(Macro.t(), list(), Macro.Env.t() | keyword()) ::
  {term(), binding :: list()}

उद्धृत सामग्री का मूल्यांकन करता है।

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

बाइंडिंग और विकल्पों के विवरण के लिए eval_string/3 देखें।

उदाहरण

iex> contents = quote(do: var!(a) + var!(b))
iex> Code.eval_quoted(contents, [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
{3, [a: 1, b: 2]}

सुविधा के लिए, आप opts तर्क के रूप में __ENV__/0 पास कर सकते हैं और सभी विकल्प वर्तमान उपयोगकर्ता से स्वचालित रूप से निकाले जाएंगे:

iex> contents = quote(do: var!(a) + var!(b))
iex> Code.eval_quoted(contents, [a: 1, b: 2], __ENV__)
{3, [a: 1, b: 2]}

eval_string (स्ट्रिंग, बाइंडिंग \\ [], opts \\ [])

eval_string(List.Chars.t(), list(), Macro.Env.t() | keyword()) ::
  {term(), binding :: list()}

string द्वारा दी गई सामग्री का मूल्यांकन करता है।

binding तर्क वैरिएबल बाइंडिंग की एक कीवर्ड सूची है। opts तर्क पर्यावरण विकल्पों की एक खोजशब्द सूची है।

चेतावनी : string किसी भी एलिक्सिर कोड हो सकती है और एर्लैंग वीएम के समान विशेषाधिकार के साथ निष्पादित की जाएगी: इसका मतलब है कि इस तरह के कोड मशीन से समझौता कर सकते हैं (उदाहरण के लिए सिस्टम कमांड निष्पादित करके)। अविश्वासित इनपुट (जैसे कि नेटवर्क से आने वाले तार) के साथ eval_string/3 उपयोग न करें।

विकल्प

विकल्प हो सकते हैं:

  • :file - मूल्यांकन में मानी जाने वाली फ़ाइल

  • :line - वह लाइन जिस पर स्क्रिप्ट शुरू होती है

साथ ही, निम्न गुंजाइश मान कॉन्फ़िगर किए जा सकते हैं:

  • :aliases - उपनाम और उसके लक्ष्य के साथ ट्यूपल्स की एक सूची

  • :requires - आवश्यक मॉड्यूल की एक सूची

  • :functions - ट्यूपल्स की एक सूची जहां पहला तत्व एक मॉड्यूल है और दूसरा आयातित फ़ंक्शन नाम और आर्इटी की एक सूची है; फ़ंक्शन नामों और आर्इटी की सूची को क्रमबद्ध किया जाना चाहिए

  • :macros - टुपल्स की एक सूची जहां पहला तत्व एक मॉड्यूल है और दूसरा आयातित मैक्रो नामों और आर्इटी की एक सूची है; फ़ंक्शन नामों और आर्इटी की सूची को क्रमबद्ध किया जाना चाहिए

ध्यान दें कि ऊपर दिए गए किसी भी मान को स्थापित करने से एलिक्ज़िर के डिफ़ॉल्ट मानों को ओवरराइड किया जा सकता है। उदाहरण के लिए, सेटिंग :requires है [] अब स्वचालित रूप से Kernel मॉड्यूल की आवश्यकता नहीं होगी। उसी तरह सेटिंग :macros अब Kernel Kernel.if/2 , Kernel.SpecialForms.case/2 और जैसे Kernel मैक्रो को ऑटो-आयात नहीं करेगा।

प्रपत्र {value, binding} का एक टपल लौटाता है, जहाँ value string मूल्यांकन करने से लौटाया गया मान होता है। यदि string का मूल्यांकन करते समय कोई त्रुटि होती है तो एक अपवाद उठाया जाएगा।

binding एक खोजशब्द सूची है जिसमें string मूल्यांकन करने के बाद सभी चर बाइंडिंग के मूल्य हैं। बाइंडिंग कुंजी आमतौर पर एक परमाणु है, लेकिन यह एक अलग संदर्भ में परिभाषित चर के लिए टपल हो सकता है।

उदाहरण

iex> Code.eval_string("a + b", [a: 1, b: 2], file: __ENV__.file, line: __ENV__.line)
{3, [a: 1, b: 2]}

iex> Code.eval_string("c = a + b", [a: 1, b: 2], __ENV__)
{3, [a: 1, b: 2, c: 3]}

iex> Code.eval_string("a = a + b", [a: 1, b: 2])
{3, [a: 3, b: 2]}

सुविधा के लिए, आप __ENV__/0 को opts तर्क और सभी आयात, आवश्यकता और मौजूदा वातावरण में परिभाषित उपनामों के रूप में पारित कर सकते हैं:

iex> Code.eval_string("a + b", [a: 1, b: 2], __ENV__)
{3, [a: 1, b: 2]}

fetch_docs (मॉड्यूल) (1.7.0 के बाद से)

fetch_docs(module() | String.t()) ::
  {:docs_v1, anno, beam_language, format, module_doc :: doc, metadata,
   docs :: [{{kind, name, arity()}, anno, signature, doc, metadata}]}
  | {:error, :module_not_found | :chunk_not_found | {:invalid_chunk, binary()}}
  | future_formats
when anno: :erl_anno.anno(),
     beam_language: atom(),
     format: binary(),
     doc: %{optional(binary()) => binary()} | :none | :hidden,
     kind: atom(),
     name: atom(),
     signature: [binary()],
     metadata: map(),
     future_formats: term()

दिए गए मॉड्यूल के लिए डॉक्स लौटाता है।

जब एक मॉड्यूल नाम दिया जाता है, तो वह अपना BEAM कोड पाता है और उसमें से डॉक्स पढ़ता है।

जब एक .beam फ़ाइल को पथ दिया जाता है, तो वह डॉक्स को सीधे उस फ़ाइल से लोड कर देगा।

यह EEP 48 या {:error, reason} द्वारा परिभाषित प्रारूप में डॉक्यूमेंट चंक में स्टोर किए गए शब्द को लौटाता है यदि चंक उपलब्ध नहीं है।

उदाहरण

# Module documentation of an existing module
iex> {:docs_v1, _, :elixir, _, %{"en" => module_doc}, _, _} = Code.fetch_docs(Atom)
iex> module_doc |> String.split("\n") |> Enum.at(0)
"Convenience functions for working with atoms."

# A module that doesn't exist
iex> Code.fetch_docs(ModuleNotGood)
{:error, :module_not_found}

format_file! (फ़ाइल, opts \\ []) (1.6.0 के बाद से)

format_file!(binary(), keyword()) :: iodata()

एक फ़ाइल को प्रारूपित करता है।

कोड स्वरूपण और उपलब्ध विकल्पों के बारे में अधिक जानकारी के लिए format_string!/2 देखें।

format_string! (स्ट्रिंग, opts \\ []) (1.6.0 के बाद से)

format_string!(binary(), keyword()) :: iodata()

दिए गए कोड string

सूत्रकार को अमृत कोड का प्रतिनिधित्व करने वाला एक स्ट्रिंग मिलता है और पूर्व निर्धारित नियमों के अनुसार स्वरूपित कोड का प्रतिनिधित्व करते हुए आयोडेटा लौटाता है।

विकल्प

  • :file - वह फाइल जिसमें स्ट्रिंग होती है, जिसका उपयोग त्रुटि रिपोर्टिंग के लिए किया जाता है

  • :line - वह रेखा जो स्ट्रिंग शुरू होती है, त्रुटि रिपोर्टिंग के लिए उपयोग की जाती है

  • :line_length - दस्तावेज़ को स्वरूपित करते समय लक्ष्य करने के लिए लाइन की लंबाई। डिफॉल्ट्स टू 98. ध्यान दें कि यह मान संदर्भ के रूप में उपयोग किया जाता है, लेकिन यह फ़ॉर्मेटर द्वारा लागू नहीं किया जाता है क्योंकि कभी-कभी उपयोगकर्ता के हस्तक्षेप की आवश्यकता होती है। "फ़ॉर्मेटर रनिंग" अनुभाग देखें

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

  • :rename_deprecated_at - दिए गए संस्करण में सभी ज्ञात पदावनत कार्यों को उनके गैर-पदावनत समकक्ष के नाम दें। यह एक वैध Version उम्मीद करता है जो आमतौर पर परियोजना द्वारा समर्थित न्यूनतम अमृत संस्करण है।

डिज़ाइन सिद्धांत

फ़ॉर्मेटर को तीन सिद्धांतों के तहत डिज़ाइन किया गया था।

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

दूसरा सिद्धांत जितना संभव हो उतना कम कॉन्फ़िगरेशन प्रदान करना है। यह एक बिंदु के रूप में समुदाय द्वारा लगातार एक के बाद एक निरंतर शैली सुनिश्चित करते हुए विवाद बिंदुओं को हटाकर फ़ॉर्मेटर गोद लेने को आसान बनाता है।

फ़ॉर्मेटर में हार्ड कोड नाम नहीं होते हैं। defmodule विशेष रूप से व्यवहार नहीं करेगा क्योंकि एक फ़ंक्शन का नाम defmodule , def , आदि है। यह सिद्धांत defmodule एक एक्स्टेंसिबल भाषा होने के लक्ष्य को defmodule जहां डेवलपर्स भाषा को नए निर्माणों के साथ विस्तारित कर सकते हैं जैसे कि वे भाषा का हिस्सा थे। जब नाम के आधार पर व्यवहार को बदलना पूरी तरह से आवश्यक है, तो यह व्यवहार विन्यास योग्य होना चाहिए, जैसे :locals_without_parens विकल्प।

फॉर्मेटर चलाना

फॉर्मेटर एक लाइन पर सबसे अधिक फिट करने का प्रयास करता है और जब भी संभव नहीं होता है तो लाइन ब्रेक का परिचय देता है।

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

आइए कुछ उदाहरण देखें। नीचे दिए गए कोड:

"this is a very long string ... #{inspect(some_value)}"

इस रूप में स्वरूपित किया जा सकता है:

"this is a very long string ... #{
  inspect(some_value)
}"

ऐसा इसलिए होता है क्योंकि कोड शब्दार्थ में बदलाव किए बिना एकमात्र स्थान फॉर्मेटर एक नई लाइन पेश कर सकता है। उन परिदृश्यों में, हम डेवलपर्स को कोड को सीधे समायोजित करने की सलाह देते हैं। यहां हम बाइनरी कॉन्टेनेशन ऑपरेटर <>/2 उपयोग कर सकते हैं:

"this is a very long string " <>
  "... #{inspect(some_value)}"

स्ट्रिंग संघनन एक लाइन पर कोड को फिट बनाता है और फॉर्मेटर को भी अधिक विकल्प देता है।

एक समान उदाहरण तब होता है जब फॉर्मेटर कई खंडों पर एक फ़ंक्शन परिभाषा को तोड़ता है:

def my_function(
  %User{name: name, age: age, ...},
  arg1,
  arg2
) do
  ...
end

हालांकि उपरोक्त कोड पूरी तरह से मान्य है, आप एकल कोड पर परिभाषा रखने के लिए फ़ंक्शन बॉडी के अंदर मौजूद स्ट्रक्चर वेरिएबल्स पर मैच करना पसंद कर सकते हैं:

def my_function(%User{} = user, arg1, arg2) do
  %{name: name, age: age, ...} = user
  ...
end

कुछ स्थितियों में, आप इस तथ्य का उपयोग कर सकते हैं कि फॉर्मेटर रिफैक्टिंग के लिए संकेत के रूप में सुरुचिपूर्ण कोड उत्पन्न नहीं करता है। यह कोड लें:

def board?(board_id, %User{} = user, available_permissions, required_permissions) do
  Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and
    required_permissions == Enum.to_list(MapSet.intersection(MapSet.new(required_permissions), MapSet.new(available_permissions)))
end

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

def board?(board_id, %User{} = user, available_permissions, required_permissions) do
  Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and
    required_permissions ==
      Enum.to_list(
        MapSet.intersection(
          MapSet.new(required_permissions),
          MapSet.new(available_permissions)
        )
      )
end

ऐसे मामलों को एक सुझाव के रूप में लें कि आपके कोड को फिर से सक्रिय किया जाना चाहिए:

def board?(board_id, %User{} = user, available_permissions, required_permissions) do
  Tracker.OrganizationMembers.user_in_organization?(user.id, board.organization_id) and
    matching_permissions?(required_permissions, available_permissions)
end

defp matching_permissions?(required_permissions, available_permissions) do
  intersection =
    required_permissions
    |> MapSet.new()
    |> MapSet.intersection(MapSet.new(available_permissions))
    |> Enum.to_list()

  required_permissions == intersection
end

इसे समाप्‍त करने के लिए: क्‍योंकि फॉर्मैटर आपके कोड के शब्दार्थों को नहीं बदल सकता है, कभी-कभी इष्टतम स्वरूपण प्राप्त करने के लिए कोड को ट्विक या रीफ़्रैक्टर करना आवश्यक होता है। फ़ॉर्मेटर को नियंत्रित करने के तरीके को बेहतर ढंग से समझने में मदद करने के लिए, हम अगले खंडों में उन मामलों का वर्णन करते हैं, जहाँ फ़ॉर्मेटर उपयोगकर्ता को एन्कोडिंग रखता है और बहुस्तरीय अभिव्यक्तियों को कैसे नियंत्रित करता है।

उपयोगकर्ता के स्वरूपण को बनाए रखना

फॉर्मेटर कुछ मामलों में इनपुट प्रारूप का सम्मान करता है। वे नीचे सूचीबद्ध हैं:

  • संख्या में तुच्छ अंकों को वैसे ही रखा जाता है। हालाँकि फ़ॉर्मेटर हमेशा 5 से अधिक अंकों के साथ दशमलव संख्याओं के लिए अंडरस्कोर सम्मिलित करता है और हेक्साडेसिमल अंकों को अपरकेस में परिवर्तित करता है।

  • स्ट्रिंग्स, चार्लिस्ट्स, परमाणु और सिगिल्स को रखा गया है। कोई भी चरित्र अपने आप बच नहीं पाता है और न ही बच पाता है। सीमांकक की पसंद का भी इनपुट से सम्मान किया जाता है

  • ब्लॉक के अंदर के न्यूलाइन्स को इनपुट के रूप में रखा गया है: 1) कई लाइनों को लेने वाले भावों में हमेशा एक खाली लाइन पहले और बाद में और 2) खाली लाइनों को हमेशा एक ही खाली लाइन में एक साथ निचोड़ा जाता है

  • उपयोगकर्ता के :do कीवर्ड और do/end ब्लॉक के बीच का विकल्प बचा है

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

  • पाइपलाइन संचालक, जैसे |> और एक ही पूर्वता वाले अन्य, कई पंक्तियों को फैलाएंगे यदि वे इनपुट में कई पंक्तियों को फैलाते हैं

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

मल्टी-लाइन सूची, नक्शे, टुपल्स, आदि

आप सूची, ट्यूपल्स, बिटस्ट्रिंग्स, मैप्स, स्ट्रक्चर्स और फंक्शन कॉल्स को एक लाइन में एक एंट्री कर सकते हैं जिसमें ओपनिंग ब्रैकेट के बाद एक नई लाइन और क्लोजिंग ब्रैकेट लाइनों से पहले एक नई लाइन है। उदाहरण के लिए:

[
  foo,
  bar
]

यदि कोष्ठक के चारों ओर कोई नई रेखा नहीं है, तो फ़ॉर्मेटर एक रेखा पर सब कुछ फिट करने की कोशिश करेगा, जैसे कि नीचे की ओर

[foo,
 bar]

के रूप में स्वरूपित किया जाएगा

[foo, bar]

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

defstruct name: nil,
          age: 0

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

फ़ंक्शन कॉल में Parens और कोई Parens नहीं

फ़ंक्शन कॉल के लिए अमृत में दो सिंटैक्स हैं। Parens और कोई Parens के साथ। डिफ़ॉल्ट रूप से, अमृत को छोड़कर सभी कॉलों के लिए पार्न्स जोड़ देगा:

  1. ऐसे कॉल जिनमें कॉल / एंड ब्लॉक होते हैं
  2. स्थानीय कॉल बिना परेंस के जहां स्थानीय कॉल का नाम और :locals_without_parens भी सूचीबद्ध है :locals_without_parens ( :locals_without_parens 0 के साथ कॉल को छोड़कर, जहां कंपाइलर को हमेशा :locals_without_parens आवश्यकता होती है)

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

some_call(
  arg1,
  arg2,
  arg3
)

दूसरी ओर, फ़ंक्शन कॉल बिना परेंस हमेशा फ़ंक्शन कॉल लंबाई से प्रेरित होते हैं, जैसे:

some_call arg1,
          arg2,
          arg3

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

Enum.reduce(some_collection, initial_value, fn element, acc ->
  # code
end)

some_function_without_parens %{
  foo: :bar,
  baz: :bat
}

कोड टिप्पणियाँ

फ़ॉर्मेटर कोड की टिप्पणियों को भी एक तरह से गारंटी देता है कि स्पेस हमेशा टिप्पणी की शुरुआत (#) और अगले चरित्र के बीच जोड़ा जाता है।

सूत्रकार अपनी पिछली पंक्ति में सभी अनुगामी टिप्पणियों को भी निकालता है। उदाहरण के लिए, नीचे दिया गया कोड

hello #world

को फिर से लिखा जाएगा

# world
hello

क्योंकि कोड टिप्पणियों को कोड प्रतिनिधित्व (एएसटी) के अलावा नियंत्रित किया जाता है, कुछ परिस्थितियां हैं जहां कोड टिप्पणियों को कोड फॉर्मेटर द्वारा अस्पष्ट के रूप में देखा जाता है। उदाहरण के लिए, नीचे अनाम फ़ंक्शन में टिप्पणी

fn
  arg1 ->
    body1
    # comment

  arg2 ->
    body2
end

और इस एक में

fn
  arg1 ->
    body1

  # comment
  arg2 ->
    body2
end

समतुल्य माना जाता है (अधिकांश उपयोगकर्ता प्रारूपण के साथ नेस्टिंग को छोड़ दिया जाता है)। ऐसे मामलों में, कोड फॉर्मेटर हमेशा बाद वाले को प्रारूपित करेगा।

get_docs (मॉड्यूल, तरह)

get_docs(module(), :moduledoc | :docs | :callback_docs | :type_docs | :all) ::
  nil
इस फ़ंक्शन को पदावनत किया जाता है। Code.get_docs / 2 हमेशा शून्य रिटर्न करता है क्योंकि इसका पुराना प्रलेखन अब BEAM फ़ाइलों पर संग्रहीत नहीं है। इसके बजाय Code.fetch_docs / 1 का उपयोग करें।

पुराने प्रलेखन प्रारूप को पुनः प्राप्त करने के लिए पदावनत समारोह।

अमृत ​​v1.7 ने ईईपी 48 को अपनाया जो एक नया प्रलेखन प्रारूप है जिसका अर्थ सभी बीईएम भाषाओं में साझा किया जाना है। पुराना स्वरूप, जिसका उपयोग Code.get_docs/2 द्वारा किया जाता है, अब उपलब्ध नहीं है, और इसलिए यह फ़ंक्शन हमेशा nil देता है। इसके बजाय Code.fetch_docs/1 उपयोग करें।

prepend_path (पथ)

prepend_path(Path.t()) :: true | {:error, :bad_directory}

Erlang VM कोड पथ सूची की शुरुआत के लिए एक पथ प्रस्तुत करता है।

यह मॉड्यूल कोड खोजने के लिए Erlang VM उपयोगों की निर्देशिकाओं की सूची है।

मार्ग का विस्तार पूर्व होने से पहले Path.expand/1 साथ किया जाता है। यदि यह पथ मौजूद नहीं है, तो एक त्रुटि वापस आ जाती है।

उदाहरण

Code.prepend_path(".")
#=> true

Code.prepend_path("/does_not_exist")
#=> {:error, :bad_directory}

purge_compiler_modules () (1.7.0 से)

purge_compiler_modules() :: {:ok, non_neg_integer()}

पर्ज कंपाइलर मॉड्यूल।

संकलक कोड को संकलित करने के लिए अस्थायी मॉड्यूल का उपयोग करता है। उदाहरण के लिए, elixir_compiler_1 , elixir_compiler_2 , आदि। यदि संकलित कोड अनाम कार्यों या समान के संदर्भों को संकलित करता है, तो Elixir संकलक उन मॉड्यूल को पुनः प्राप्त करने में असमर्थ हो सकता है, जो कोड की एक आवश्यक मात्रा को स्मृति में रखते हैं और अंततः elixir_compiler_12345 जैसे मॉड्यूल की ओर ले elixir_compiler_12345

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

यह {:ok, number_of_modules_purged}

आवश्यकता_फाइल (फ़ाइल, रिश्तेदार_तक \\ नील)

require_file(binary(), nil | binary()) :: [{module(), binary()}] | nil

दी गई file

जहाँ फ़ाइल स्थित है यह बताने के लिए एक तर्क के रूप में सापेक्ष_को स्वीकार करता है। यदि फ़ाइल पहले से ही आवश्यक थी, तो require_file/2 कुछ भी नहीं करता है और nil लौटाता है।

ध्यान दें कि यदि आवश्यक require_file/2 अलग-अलग प्रक्रियाओं द्वारा समवर्ती रूप से लागू किया गया है, तो require_file/2 को लागू करने वाली पहली प्रक्रिया एक ताला प्राप्त करती है और शेष तब तक अवरुद्ध हो जाती है जब तक फ़ाइल उपलब्ध नहीं होती है। इसका मतलब यह है कि यदि एक फ़ाइल के साथ एक बार से अधिक आवश्यकता होती है, तो उस फ़ाइल को केवल एक बार संकलित किया जाएगा। आवश्यकता_फाइल require_file/2 को कॉल करने की पहली प्रक्रिया को लोड किए गए मॉड्यूल की सूची मिलेगी, दूसरों को nil मिलेगा।

यदि आप इसके फ़ाइलनाम को ट्रैक किए बिना किसी फ़ाइल को संकलित करना चाहते हैं तो compile_file/2 देखें। अंत में, यदि आप इसमें परिभाषित मॉड्यूल के बजाय फ़ाइल के मूल्यांकन का परिणाम प्राप्त करना चाहते हैं, तो eval_file/2

उदाहरण

यदि फ़ाइल आवश्यक नहीं है, तो यह मॉड्यूल की सूची लौटाता है:

modules = Code.require_file("eex_test.exs", "../eex/test")
List.first(modules)
#=> {EExTest.Compiled, <<70, 79, 82, 49, ...>>}

यदि कोड आवश्यक है, तो यह nil :

Code.require_file("eex_test.exs", "../eex/test")
#=> nil

आवश्यक_फाइल्स () (1.7.0 के बाद से)

required_files() :: [binary()]

सभी आवश्यक फ़ाइलों को सूचीबद्ध करता है।

उदाहरण

Code.require_file("../eex/test/eex_test.exs")
List.first(Code.required_files()) =~ "eex_test.exs"
#=> true

string_to_quoted! (string, opts \\ [])

string_to_quoted!(List.Chars.t(), keyword()) :: Macro.t()

दिए गए स्ट्रिंग को उसके उद्धृत रूप में परिवर्तित करता है।

यदि यह सफल हो जाता है तो यह वापस आ जाता है, अन्यथा एक अपवाद को जन्म देता है। अपवाद TokenMissingError है यदि कोई टोकन गायब है (आमतौर पर क्योंकि अभिव्यक्ति अधूरी है), SyntaxError अन्यथा।

विकल्पों की जानकारी के लिए string_to_quoted/2 जाँच करें।

string_to_quoted (स्ट्रिंग, opts \\ [])

string_to_quoted(List.Chars.t(), keyword()) ::
  {:ok, Macro.t()} | {:error, {line :: pos_integer(), term(), term()}}

दिए गए स्ट्रिंग को उसके उद्धृत रूप में परिवर्तित करता है।

यदि यह सफल होता है, तो {:ok, quoted_form} रिटर्न {:ok, quoted_form} {:error, {line, error, token}}

विकल्प

  • :file - :file नाम पार्सिंग त्रुटियों के मामले में रिपोर्ट किया जाना है। "नाकाम" करने के लिए चूक।

  • :line - स्ट्रिंग की प्रारंभिक लाइन पार्स की जा रही है। 1 से चूक।

  • :columns - जब true , उद्धृत मेटाडेटा के लिए एक :column कुंजी संलग्न :column false अवहेलना करता false

  • :existing_atoms_only - जब true होता true , तो एक त्रुटि उठाता है जब गैर-मौजूदा परमाणु टोकनधारक द्वारा पाए जाते हैं। false अवहेलना।

  • :warn_on_unnecessary_quotes - जब false , जब परमाणु, कीवर्ड या कॉल उन पर अनावश्यक उद्धरण नहीं चेतावनी देते हैं। true अवहेलना।

Macro.to_string/2

एक स्ट्रिंग को उसके उद्धृत रूप में परिवर्तित करने के विपरीत Macro.to_string/2 , जो एक उद्धृत रूप को स्ट्रिंग / बाइनरी प्रतिनिधित्व में परिवर्तित करता है।

unrequire_files (फाइलें) (1.7.0 के बाद से)

unrequire_files([binary()]) :: :ok

आवश्यक फ़ाइलों की सूची से फ़ाइलें निकालता है।

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

उदाहरण

# Require EEx test code
Code.require_file("../eex/test/eex_test.exs")

# Now unrequire all files
Code.unrequire_files(Code.required_files())

# Notice modules are still available
function_exported?(EExTest.Compiled, :before_compile, 0)
#=> true

Original text