👃🏻 🏭 🏂🏽 छोटों के लिए एरलांग। अध्याय 1: डेटा प्रकार, चर, सूचियाँ और टुपल्स ⚽️ 🖕🏾 🍬

शुभ दोपहर, प्रिय फेरीवाले।

यह एक श्रृंखला का पहला लेख है। कई लोगों के लिए, यह बहुत ही भयावह लग सकता है क्योंकि मूल बातें यहां चर्चा की गई हैं। लेकिन शुरुआती लोगों के लिए, यह उपयोगी होगा, इसलिए आप इसके बिना नहीं कर सकते। यह कुछ दिलचस्प और गैर-स्पष्ट बिंदुओं पर ध्यान आकर्षित करता है।

अध्याय सूची

अध्याय 1: डेटा प्रकार, चर, सूचियाँ और टुपल्स ( गीथूब )
अध्याय 2: मॉड्यूल और कार्य ( गिटब )
अध्याय 3: बेसिक फंक्शन सिंटेक्स (पूर्ण) ( जीथूब )
अध्याय 4: टाइप सिस्टम ( जीथब )
सात एर्लांग प्रदर्शन मिथक

टर्मिनल में एर्लांग के साथ काम करना शुरू करने के लिए:

$ sudo apt-get install erlang $ erl

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

तो चलिए शुरू करते हैं।

संख्या

एरलैंग दो प्रकार के संख्यात्मक चर का समर्थन करता है: पूर्णांक और फ्लोटिंग-पॉइंट संख्या। आप संख्याओं, घटाव, गुणा और भाग जैसे गणितीय कार्यों को कर सकते हैं:

  1> 7 + 3. 10 2> 12 - 4. 8 3> 5 * 2. 10 4> 12 / 6 2.0 5> 7 div 3. 2 6> 7 rem 3. 1

ध्यान दें कि विभाजन का परिणाम एक अस्थायी बिंदु संख्या था। Erlang स्वचालित रूप से सही प्रकार के संख्यात्मक चर डालने के लिए पर्याप्त स्मार्ट है।

एर्लैंग आपको एक बार में कई ऑपरेशन करने की अनुमति देता है। गणितीय संचालन मानक प्राथमिकता नियमों का पालन करते हैं। इसलिए, अभिव्यक्ति 2 + 3 * 4. का परिणाम 14 होगा, क्योंकि गुणन में जोड़ की तुलना में अधिक प्राथमिकता है। गणना के क्रम को स्पष्ट रूप से सेट करने के लिए, आपको कोष्ठक का उपयोग करने की आवश्यकता है:

  1> (2 + 3) * 4. 20 2> -(10 + 3). -13

इसके अलावा, आप केवल दशमलव संख्या प्रणाली तक सीमित होने के लिए बाध्य नहीं हैं। आप 2 से 36 तक किसी भी आधार के साथ संख्याओं का उपयोग कर सकते हैं। इसके लिए, संख्या को Base#Value के रूप में निर्दिष्ट किया जाना चाहिए।

  1> 2#11011. 27 2> 10#1198. 1198 3> 16#A04F. 41295 4> 36#1TA. 2350

लेकिन यह सब नहीं है। Erlang में, आप एक अभिव्यक्ति में विभिन्न आधारों के साथ संख्याओं का उपयोग कर सकते हैं:

  1> 2#11011 + 36#1TA. 2377 2> 10#1198 - 16#A04F. -39841 3> 3#201 * 4#321. 1083

परमाणुओं

परमाणु अन्य भाषाओं के नामित स्थिरांक का एक एनालॉग हैं, और एक परमाणु का मूल्य इसके नाम से बिल्कुल मेल खाता है। मोटे तौर पर, एक परमाणु एक स्ट्रिंग है जिसे बदला नहीं जा सकता है।

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

after and andalso band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse query receive rem try when xor

नहीं

after and andalso band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse query receive rem try when xor

की अनुमति नहीं

after and andalso band begin bnot bor bsl bsr bxor case catch cond div end fun if let not of or orelse query receive rem try when xor

।

  1> atom. atom 2> otherAtom. otherAtom 3> atom_with_underscore. atom_with_underscore 4> one@more@atom. one@more@atom 5> 'Atom with whitespace'. 'Atom with whitespace' 6> ' Atom with special charactes #^&?'. ' Atom with special charactes #^&?' 7> Atom. * 1: variable 'Atom' is unbound 8> after. * 1: syntax error before: 'after'

तार्किक डेटा प्रकार और तुलना ऑपरेटर

एरलैंग के बूलियन डेटा प्रकार दो आरक्षित परमाणु हैं: true और false ।
इसके साथ एक जिज्ञासु और असंदिग्ध तथ्य जुड़ा हुआ है। लेकिन उस पर और बाद में।

भाषा "और" ( and ), "या" ( or ), "अनन्य या" ( xor ) और "निषेध" ( not ) जैसे सभी बुनियादी तार्किक कार्यों को लागू करती है।

  1> true or false. true 2> true and false. false 3> true xor false. true 4> not false. true 5> (not (true xor true)) or (false and true). true

और or ऑपरेटर हमेशा स्वयं के दोनों ओर अभिव्यक्ति मूल्यों का मूल्यांकन करते हैं। इसलिए, कोड निष्पादित करते समय (1 > 2) or (3 < 4). दोनों अभिव्यक्तियों के मूल्य मिलेंगे, हालांकि सही अभिव्यक्ति की गणना के बाद, परिणाम पहले से ही ज्ञात है। यदि आप इससे बचना चाहते हैं, andalso और orelse उपयोग करें।

एक दूसरे के साथ मूल्यों की तुलना करने के लिए, ऑपरेटर "बराबर" ( == ), "क्रमशः बराबर" ( =:= ), "क्रमशः असमान" ( =/= ), "असमान" ( /= ), "कम" ( < ) हैं। ( =< ) से कम या अधिक ( > ) से अधिक या ( >= ) के बराबर या उससे अधिक।

  1> 2 == 2.0. true 2> 2 =:= 2.0. false 3> 3 /= 3.0. false 4> 3 =/= 3.0. true 5> 5 > 5. false 6> 5 =< 5. true

यदि आप अन्य भाषाओं में कार्यक्रम करते थे, तो आप सबसे अधिक इस तथ्य के लिए उपयोग किए जाते हैं कि उनमें true 1 है और false 0 । एर्लैंग में, यह नियम काम नहीं करता है:

  1> true == 1. false 2> false == 0. false 3> false > 19. %% !!! true

क्या आपने तीसरी पंक्ति पर ध्यान दिया है? अजीब है, है ना? और पूरा बिंदु यह है कि एर्लैंग आपको विभिन्न प्रकारों के मूल्यों की तुलना करने की अनुमति देता है और तुलना करते समय निम्नलिखित नियम द्वारा निर्देशित किया जाता है: (number) < (atom) < (reference) < (fun) < (port) < (pid) < (tuple) < (list) < (bit string) हमने कहा कि true और false परमाणु हैं, और उपरोक्त अभिव्यक्ति से यह स्पष्ट है कि परमाणु संख्या की तुलना में "अधिक" हैं। इसलिए, यह पता चलता है कि false > 19. ।।

चर

शुद्ध कार्यात्मक भाषाओं (जैसे हास्केल) में कोई चर नहीं होते हैं। एरलैंग हमें चर बनाने की अनुमति देता है, लेकिन एक सीमा के साथ: एक चर का मूल्य केवल एक बार सौंपा जा सकता है। मान पुन: असाइन करने से त्रुटि होगी।

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

  1> Variable = 10 - 7. 3 2> OtherVariable = 3 * 4. 12 3> _result = Variable + OtherVariable. 15 4> _result. 15 5> Variable = 5. ** exception error: no match of right hand side value 5

tuples

कभी-कभी चर का एक समूह जो किसी तरह एक-दूसरे से संबंधित होता है, एक साथ स्टोर करना अधिक सुविधाजनक होता है। एर्लैंग इसके लिए एक टपल जैसा निर्माण प्रदान करता है। एक tuple का निम्न रूप है: {Value1, Value2, ..., ValueN} और इसमें कई प्रकार के चर हो सकते हैं।

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

  1> MyPoint = {2,5}. {2,5}

जैसा कि ऊपर बताया गया है, एक टपल का आकार दो मूल्यों तक सीमित नहीं है। एक टपल में विभिन्न प्रकारों के मान भी हो सकते हैं, जिसमें अन्य टुपल्स भी शामिल हैं।

  1> MyTuple = {1,myAtom,true,{1,false}}. {1,myAtom,true,{1,false}}

पैटर्न मिलान

टपल से मान निकालने के लिए (और न केवल इसके लिए), पैटर्न मिलान का उपयोग किया जाता है। आरंभ करने के लिए, आइए देखें कि मिलान ऑपरेटर ( = ) फिर से कैसे काम करता है। यह दाईं ओर मान लेता है और उनकी तुलना बाईं ओर चर के साथ करता है। मोटे तौर पर, यह केवल एक अंतर के साथ अनिवार्य भाषाओं से एक ही काम है: केवल असंबंधित चर की तुलना की जा सकती है, अर्थात जिनका अभी कोई अर्थ नहीं है।

पैटर्न मिलान तब होता है जब एक एकल चर के बजाय "टेम्पलेट" निर्दिष्ट किया जाता है, जो डेटा से मेल खाना चाहिए। और यदि डेटा टेम्प्लेट से मेल खाता है, तो इस टेम्प्लेट से चर को संबंधित मानों में मैप किया जाएगा।

  1> {X,Y} = {1,2}. {1,2} 2> X. 1 3> Y. 2 4> Z = {Y,X}. {2,1} 5> {A,B,C} = {myAtom,true,Z}. {myAtom,true,{2,1}} 6> A. myAtom 7> B. true 8> C. {2,1}

पैटर्न मिलान कार्यात्मक भाषाओं के सबसे शक्तिशाली उपकरणों में से एक है और इसका उपयोग केवल टुपल्स से डेटा निकालने के लिए नहीं किया जाता है। अगला, हम इस तकनीक का उपयोग अक्सर करेंगे।

हमें हमेशा सभी डेटा की आवश्यकता नहीं होती है। उदाहरण के लिए, हमें केवल एक ट्रिपल के दूसरे मूल्य की आवश्यकता हो सकती है (एक ट्रिपल तीन मूल्यों का एक टपल है)। बेकार संस्थाओं को "उत्पादन" नहीं करने के लिए, हम उस विशेष चर का उपयोग कर सकते हैं जो पहले उल्लेख किया गया था: _ । इस प्रकार, हम इंगित करते हैं कि टेम्पलेट के इस स्थान पर कुछ मूल्य होना चाहिए, लेकिन हमें इसकी आवश्यकता नहीं है। इसके अलावा, टेम्पलेट में कई ऐसे चर हो सकते हैं। सुविधाजनक है, है ना?

  1> {_,X,_} = {1,2,3}. {1,2,3} 2> X. 2

सूचियों

एक सूची अनिवार्य भाषाओं से सरणियों का एक एनालॉग है। सूची इस प्रकार है: [Value1, Value2, ..., ValueN] । सूची आइटम को एक ही प्रकार का नहीं होना चाहिए। एक सूची में संख्याएँ, परमाणु, ट्यूपल्स, अन्य सूचियाँ आदि हो सकती हैं।

  1> [1,2,true,atom,{5,4},[true,false]]. [1,2,true,atom,{5,4},[true,false]].

Erlang में सूचियों के साथ काम करते समय, एक अजीब बात है:

  1> [100,101,102,103]. "defg"

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

सूचियों ( ++ ) को जोड़ा जा सकता है और एक दूसरे से घटाया जा सकता है ( -- )। याद रखें कि ये ऑपरेटर भी सहयोगी हैं।

  1> [1,2,3,4,5] ++ [6,7]. [1,2,3,4,5,6,7] 2> [1,2,3,4,5] -- [2,3]. [1,4,5] 3> [1,2,3] ++ []. [1,2,3] 4> [1,2,3,4,5] -- [1,2,3] -- [3]. [3,4,5] 5> [1,2,3] ++ [4,5,6] -- [4,5]. [1,2,3,6]

सूचियों की एक दूसरे के साथ तुलना भी की जा सकती है। इसके लिए, मानक तुलना ऑपरेटरों का उपयोग किया जाता है। सबसे पहले, सूचियों के प्रमुखों की तुलना की जाती है। यदि वे समान हैं, तो पूंछ के सिर की तुलना की जाती है, आदि। पहले अलग-अलग वस्तुओं पर सूचियों की तुलना की जाती है। नीचे दिए गए उदाहरण में, पहली सूची बड़ी है क्योंकि पहला तत्व जो दूसरी सूची के संबंधित तत्व से अलग है वह बड़ा है ( 4 > 1 )।

  1> [1,2,3,4,0] > [1,2,3,1,1000,2000,6589]. true

सूची को दो भागों में विभाजित किया गया है: सिर ( head ) और पूंछ ( tail )। सिर सूची का पहला तत्व है, और पूंछ बाकी सब कुछ है। पूंछ, बदले में, एक सिर और पूंछ भी है। जब एक पैटर्न के साथ मिलान, ऑपरेटर | , यह इंगित करने के लिए कि सिर और पूंछ के बीच की सीमा कहां से गुजरती है।

  1> [Head|Tail] = [1,2,3,4,5]. [1,2,3,4,5] 2> Head. 1 3> Tail. [2,3,4,5] 4> [Second|_] = Tail. [2,3,4,5] 5> Second. 2

सूची जनरेटर

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

  1> [X*3 || X <- [1,2,3,4,5,6,7,8,9,10]]. [3,6,9,12,15,18,21,24,27,30]

हमारी अभिव्यक्ति [Expr || Item <- SourceList]. [Expr || Item <- SourceList]. SourceList से प्रत्येक तत्व लेता है और उसे Item चर के स्थान पर Expr अभिव्यक्ति में प्रतिस्थापित करता है। इस अभिव्यक्ति का परिणाम परिणामी सूची में जोड़ा जाता है। काफी आसान है, है ना?

लेकिन जिस रूप में यह जनरेटर है वह अब लगभग बेकार है। आइए कार्य को जटिल करते हैं। आइए मूल सूची से केवल संख्याओं के साथ जनरेटर का काम करें, जो 5 से अधिक हैं।

  1> [X*3 || X <- [1,2,3,4,5,6,7,8,9,10], X rem 2 =:= 0, X > 5]. [18,24,30]

अब हमारे जनरेटर का रूप है [Expr || Item <- SourceList, Condition1, Condition2, ..., Condition2]. [Expr || Item <- SourceList, Condition1, Condition2, ..., Condition2]. यह पहले विकल्प की तरह ही काम करता है, लेकिन अब एरलैंग जाँचता है कि स्रोत सूची का प्रत्येक तत्व निर्दिष्ट शर्तों से मेल खाता है। यदि कोई तत्व कम से कम एक फिट नहीं है, तो इसे छोड़ दिया जाता है।

लेकिन यह सब नहीं है। कई स्रोत सूचियाँ हो सकती हैं। उदाहरण के लिए, आइए एक जनरेटर लिखें जो सम संख्याओं के सभी संभावित संयोजनों को १ से ५ तक और विषम संख्याओं को ६ से १० तक लौटाता है। युग्म को दो तत्वों के टपल द्वारा दर्शाया जाए - एक युग्म।

  1> [{X,Y} || X <- [1,2,3,4,5], Y <- [6,7,8,9,10], X rem 2 =:= 0, Y rem 2 =:= 1]. [{2,7},{2,9},{4,7},{4,9}]

सबसे सामान्य मामले में, जनरेटर का रूप है [Expr || Item1 <- SourceList1, Item2 <- SourceList2, ..., ItemN <- SourceListN, Condition1, Condition2, ..., ConditionN] [Expr || Item1 <- SourceList1, Item2 <- SourceList2, ..., ItemN <- SourceListN, Condition1, Condition2, ..., ConditionN] । इस मामले में, एरलैंग मूल सूचियों के कार्टेशियन उत्पाद को वापस कर देगा (अधिक सटीक रूप से, उनके तत्व जो शर्तों को फिट करते हैं)।

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

निष्कर्ष

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

अगले लेख में, हम देखेंगे कि मौजूदा का उपयोग कैसे करें और नए कार्यों का निर्माण करें। और मॉड्यूल के साथ भी काम करते हैं।

पढ़ने के लिए धन्यवाद। एक अच्छा कोड है।

छोटों के लिए एरलांग। अध्याय 1: डेटा प्रकार, चर, सूचियाँ और टुपल्स