छोटों के लिए एरलांग। अध्याय 2: मॉड्यूल और कार्य

शुभ संध्या, प्रिय खाबरोवचेन। हम सबसे छोटे के लिए एरलांग का अध्ययन करना जारी रखते हैं।

पिछले अध्याय में, हमने बुनियादी डेटा प्रकारों, सूचियों और टुपल्स को देखा। हमने पैटर्न मिलान और सूची जनरेटर का उपयोग करना भी सीखा।

इस अध्याय में, हम अगले चरण पर जाते हैं और मॉड्यूल और कार्यों को देखते हैं।



अध्याय के लिए स्रोत कोड यहाँ हैं ।

एरलैंग में, सभी कार्यों को मॉड्यूल में विभाजित किया गया है। कोई भी कार्य अपवाद नहीं हो सकता। भाषा के मानक कार्य जिन्हें हम "वैश्विक" कहते हैं (उदाहरण के लिए, length , hd , tl ) वास्तव में मॉड्यूल के अंदर भी हैं। ये "बिल्ट-इन फ़ंक्शंस" हैं (इन्हें BIF - बिल्ट-इन फ़ंक्शंस कहा जाता है) और ये erlang मॉड्यूल से संबंधित हैं। यह मॉड्यूल डिफ़ॉल्ट रूप से आयात किया जाता है, इसलिए आप उनके साथ अलग-अलग कार्यों के रूप में काम कर सकते हैं (आयात मॉड्यूल के लिए नीचे देखें)।

मॉड्यूल

एक मॉड्यूल तार्किक रूप से संबंधित कार्यों का एक समूह है, जो एक नाम के तहत एकजुट है। मोटे तौर पर, Erlang में मॉड्यूल अनिवार्य भाषाओं के नामस्थान के अनुरूप हैं। उनका उपयोग उन कार्यों को संयोजित करने के लिए किया जाता है जिनका एक समान उद्देश्य होता है। उदाहरण के लिए, सूचियों के साथ काम करने के लिए कार्य lists मॉड्यूल में हैं, और I / O फ़ंक्शन io मॉड्यूल में हैं।

किसी फ़ंक्शन को कॉल करने के लिए, आपको निम्न निर्माण का उपयोग करना होगा: ModuleName:FunctionName(Arg1, Arg2, ..., ArgN) । उदाहरण के लिए, हम एक फ़ंक्शन को कहते हैं जो निर्दिष्ट संख्या के साथ संचरित ट्यूपल के तत्व को वापस करता है। इस फ़ंक्शन को element कहा जाता element और यह erlang मॉड्यूल में स्थित है।

 1> erlang:element(3, {23,54,34,95}). 34 

किसी मॉड्यूल को स्पष्ट रूप से निर्दिष्ट किए बिना फ़ंक्शन को कॉल करना भी संभव है। यह थोड़ा आगे लिखा है।

मॉड्यूल कार्यों और विशेषताओं में शामिल हैं।

मॉड्यूल विशेषताएँ

विशेषताएँ वैसा ही नहीं हैं, जैसा कि अनिवार्य भाषाओं में होता है। एरलैंग में, एक मॉड्यूल की विशेषताएं इसके मेटाडेटा हैं, जैसे नाम, संस्करण, लेखक, आयातित कार्यों की सूची, आदि। विशेषताएँ संकलक द्वारा उपयोग की जाती हैं। साथ ही, उनसे एक व्यक्ति स्रोत कोड (उदाहरण के लिए, संस्करण और लेखक) को समझने के बिना मॉड्यूल के बारे में उपयोगी जानकारी प्राप्त कर सकता है।

विशेषताएँ मॉड्यूल फ़ाइल की शुरुआत में इंगित की जाती हैं और उनके निम्न रूप होते हैं: -Name(Arg). । मॉड्यूल का नाम एक परमाणु होना चाहिए। प्रत्येक विशेषता को एक अलग लाइन पर इंगित किया गया है।

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

-मॉड्यूल (नाम)।
मॉड्यूल का नाम केवल आवश्यक विशेषता है और इसे पहले निर्दिष्ट किया जाना चाहिए। इसके बिना, आपका मॉड्यूल बस संकलन नहीं करेगा। यह एक तर्क के रूप में एक परमाणु लेता है - मॉड्यूल का नाम। आइए हमारे मॉड्यूल mySuperModule का mySuperModule दें।

 -module(mySuperModule). 

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

-एक्सपोर्ट ([Fnct1 / Arity, Fnct2 / Arity, ..., FnctN / Arity]]
निर्यात किए गए कार्यों की सूची - मॉड्यूल कार्यों की एक सूची जो बाहरी रूप से उपलब्ध होगी। स्वीकृत विशेषता कार्यों की एक सूची है। यहाँ Fnct फ़ंक्शन का नाम है, और Arity उन तर्कों की संख्या है जो इसे (arity) लेता है। हमारा मॉड्यूल चार फ़ंक्शन निर्यात करेगा: add , subtr , subtr , subtr (जोड़, घटाव, गुणा, भाग)। प्रत्येक फ़ंक्शन दो तर्क लेगा।

 -export([add/2, subtr/2, mult/2, divis/2]). 

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

-पोर्ट (मॉड्यूलनाम, [Fnct1 / Arite, Fnct2 / Arity, ..., FnckN / Arity])।
यह विशेषता इंगित करती है कि हम ModuleName मॉड्यूल से सूची में निर्दिष्ट फ़ंक्शन को आयात करना चाहते हैं, जिसे दूसरे तर्क से पारित किया गया है। प्रत्येक आयातित मॉड्यूल को एक अलग विशेषता में इंगित किया गया है।

क्यों आयात करते हैं सुविधाएँ? जैसा कि ऊपर उल्लेख किया गया है, किसी फ़ंक्शन को किसी अन्य मॉड्यूल से एक्सेस करने के लिए, आपको इसके पूर्ण नाम को निर्दिष्ट करना होगा ModuleName:FunctionName() । यदि आप हर बार एक मॉड्यूल नाम निर्दिष्ट नहीं करना चाहते हैं, तो आपको इसे आयात करने की आवश्यकता है। यह विशेषता C ++ से #using निर्देश का एक एनालॉग है। लेकिन आयात का दुरुपयोग न करें। फ़ंक्शन का पूरा नाम बहुत स्पष्ट है। इसे देखकर, आप तुरंत बता सकते हैं कि किस फ़ंक्शन को मॉड्यूल कहा जाता है। एक संक्षिप्त नाम के मामले में, आपको यह याद रखना होगा कि यह फ़ंक्शन किस मॉड्यूल से आयात किया गया था।

हम पूर्ण फ़ंक्शन नामों का उपयोग करेंगे, लेकिन अगर हम छोटे नामों का उपयोग करना चाहते हैं, तो हम निम्नलिखित कुछ लिख सकते हैं:

 -import(io, [format/2]). 

ठीक है, उदाहरण के लिए, आइए कुछ मनमानी विशेषता का संकेत दें। इसे लेखक का नाम बताएं।

 -author("Haru Atari"). 

आधिकारिक दस्तावेज में पूर्वनिर्धारित विशेषताओं की पूरी सूची पाई जा सकती है।

यदि अब आप हमारे मॉड्यूल को संकलित करने का प्रयास करते हैं, तो आपको एक त्रुटि मिलेगी:

 1> c(mySuperModule). ./mySuperModule.erl:2: function add/2 undefined ./mySuperModule.erl:2: function divis/2 undefined ./mySuperModule.erl:2: function mult/2 undefined ./mySuperModule.erl:2: function subtr/2 undefined 

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

कार्यों

मूल मामले में, FnctName(Arg1, Arg2, ..., ArgN) -> FunctionBody. में कार्यों के निम्नलिखित रूप हैं: FnctName(Arg1, Arg2, ..., ArgN) -> FunctionBody. फ़ंक्शन का नाम एक परमाणु है, और इसका शरीर एक या एक से अधिक भाव अल्पविराम से अलग होता है । फ़ंक्शन बॉडी के अंत में एक बिंदी लगाई जाती है। यदि फ़ंक्शन में केवल एक ही अभिव्यक्ति है, तो इसे एक पंक्ति में लिखना अधिक स्पष्ट होगा।

 add(X, Y) -> X + Y. 

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

लेकिन हमेशा फ़ंक्शन से दूर एक अभिव्यक्ति के होते हैं। इस मामले में, फ़ंक्शन बॉडी कोड के बाकी हिस्सों के बाईं ओर स्थित है। इस मामले में, हमारा कार्य इस तरह दिखेगा:

 add(X, Y) -> doSomthing(), X + Y. 

अब शेष तीन कार्यों को स्वयं जोड़ें। हमने जो लिखा है उसका अनुभव करने के लिए अपने मॉड्यूल को संकलित करें।

संकलन

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

Erlang के लिए कई वर्चुअल मशीनें हैं। लेकिन सबसे आम बीईएएम (बोगडान / ब्योर्न की एरलैंग सार मशीन) है। कई वर्चुअल मशीनें (JAM और WAM) हैं, लेकिन इनका उपयोग लगभग नहीं किया जाता है और हम इन पर विचार नहीं करेंगे।

संकलन करने के दो तरीके हैं: टर्मिनल या एर्लांग कमांड लाइन से। आइए दोनों विकल्पों को देखें।

टर्मिनल से संकलित करने के लिए, आपको फ़ाइल के साथ निर्देशिका में जाना होगा और erlc FileName.erl कमांड को कॉल करना erlc FileName.erl । हमारे मॉड्यूल के लिए, यह इस तरह दिखाई देगा (आपके पास अपना रास्ता होगा)।

 cd ~/Erlang-for-the-little-ones/02/sources erlc mySuperModule.erl 

Erlang कमांड लाइन से ऐसा करने के लिए, आपको cd("DirName") कमांड के साथ आवश्यक निर्देशिका में भी जाना चाहिए, और फिर c(ModuleName) कॉल करना होगा। कृपया ध्यान दें कि हम फ़ाइल का नहीं, मॉड्यूल का नाम पास करते हैं। कोई एक्सटेंशन की आवश्यकता नहीं है।

 1> cd("~/Erlang-for-the-little-ones/02/sources/"). /home/haru/Erlang-for-the-little-ones/02/sources ok 2> c(mySuperModule). {ok,mySuperModule} 

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

 1> mySuperModule:add(2, 4). 6 2> mySuperModule:divis(6,4). 1.5 

यह उल्लेखनीय है कि संकलक के लिए "संकलन झंडे" को पारित करना संभव है। ऐसा करने के लिए, c() फ़ंक्शन के दूसरे तर्क को पास करें - झंडे की एक सूची। उदाहरण के लिए, हम अपने मॉड्यूल को डिबग मोड में संकलित करते हैं:

 c(mySuperModule, [debug_info]). 

हम अब इस पर ध्यान केंद्रित नहीं करेंगे। एक अलग अध्याय इस विषय के लिए समर्पित होगा। लेकिन अगर आप रुचि रखते हैं, तो चाबियों की एक सूची के साथ, आप इसे दस्तावेज़ पृष्ठ पर पा सकते हैं।

निष्कर्ष

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

अगले अध्याय में, हम और अधिक विस्तार से फ़ंक्शन के सिंटैक्स की जांच करेंगे, और यह भी सीखेंगे कि फ़ंक्शन में पैटर्न का उपयोग कैसे करें।

पढ़ने के लिए धन्यवाद। अच्छे मूड और खराब संबंध रखें।

पीएस मैं पीएम में टाइपो और त्रुटियों के बारे में सूचित करने के लिए कहता हूं। आपकी समझ के लिए धन्यवाद।