Erlang Language
जानकारी का प्रकार

टिप्पणियों

नंबर

Erlang में, संख्याएँ पूर्णांक या फ़्लोट होती हैं। Erlang पूर्णांक (bignums) के लिए मनमाना-सटीक उपयोग करता है, इसलिए उनके मान केवल आपके सिस्टम के मेमोरी साइज़ द्वारा सीमित होते हैं।

1> 11.
11
2> -44.
-44
3> 0.1.
0.1
4> 5.1e-3.
0.0051
5> 5.2e2.
520.0

विभिन्न आधारों में संख्याओं का उपयोग किया जा सकता है:

1> 2#101.
5
2> 16#ffff.
65535

$ -प्रिकोम संकेतन किसी भी ASCII / यूनिकोड वर्ण के पूर्णांक मान को प्राप्त करता है:

3> $a.
97
4> $A.
65
5> $2.
50
6> $🤖.
129302

परमाणुओं

परमाणु एक वस्तु है जिसका नाम केवल नाम से ही पहचाना जाता है।

एरोमांग में एटम शाब्दिक रूप से परमाणुओं को परिभाषित किया जाता है जो या तो हैं

• एक अयोग्य स्ट्रिंग जो एक लोअरकेस अक्षर से शुरू होती है और इसमें केवल अक्षर, अंक, अंडरस्कोर या @ वर्ण, या होते हैं
• एक एकल उद्धृत स्ट्रिंग

उदाहरण

1> hello.
hello

2> hello_world.
hello_world

3> world_Hello@.
world_Hello@

4> '1234'.     
'1234'

5> '!@#$%% ä'.
'!@#$%% ä'

अधिकांश एर्लांग कार्यक्रमों में उपयोग किए जाने वाले परमाणु

कुछ परमाणु हैं जो लगभग हर एरलांग कार्यक्रम में दिखाई देते हैं, विशेष रूप से मानक पुस्तकालय में उनके उपयोग के कारण।

• true और false का इस्तेमाल संबंधित बूलियन मूल्यों को दर्शाने के लिए किया जाता है
• ok का उपयोग आमतौर पर किसी फ़ंक्शन के रिटर्न वैल्यू के रूप में किया जाता है जिसे केवल इसके प्रभाव के लिए कहा जाता है, या रिटर्न वैल्यू के हिस्से के रूप में, दोनों मामलों में एक सफल निष्पादन को दर्शाता है।
• उसी तरह error का उपयोग एक त्रुटि स्थिति को इंगित करने के लिए किया जाता है जो ऊपरी कार्यों से जल्दी वापसी नहीं करता है
• undefined का उपयोग आमतौर पर अनिर्दिष्ट मूल्य के लिए प्लेसहोल्डर के रूप में किया जाता है

टैग के रूप में उपयोग करें

ok और error को अक्सर एक टुपल के हिस्से के रूप में उपयोग किया जाता है, जिसमें टपल के पहले तत्व को सफलता मिलती है जबकि आगे के तत्वों में वास्तविक रिटर्न वैल्यू या त्रुटि की स्थिति होती है:

func(Input) ->
    case Input of
        magic_value ->
            {ok, got_it};
        _ ->
            {error, wrong_one}
    end.

{ok, _} = func(SomeValue).

भंडारण

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

बायनेरिज़ और बिटस्ट्रिंग्स

एक बाइनरी अहस्ताक्षरित 8-बिट बाइट्स का एक क्रम है।

1> <<1,2,3,255>>.
<<1,2,3,255>>
2> <<256,257,258>>.
<<0,1,2>>
3> <<"hello","world">>.
<<"helloworld">>

एक बिटस्ट्रिंग एक सामान्यीकृत बाइनरी है जिसकी बिट्स में लंबाई आवश्यक रूप से 8 के एक से अधिक नहीं है।

1> <<1:1, 0:2, 1:1>>.
<<9:4>> % 4 bits bitstring

tuples

एक टपल एक निश्चित लंबाई का क्रम है जो अन्य एर्लांग शब्दों का क्रम है। टपल में प्रत्येक तत्व किसी भी प्रकार का शब्द (कोई भी डेटा प्रकार) हो सकता है।

1> {1, 2, 3}.
{1,2,3}
2> {one, two, three}.
{one,two,three}
3> {mix, atom, 123, {<<1,2>>, [list]}}.
{mix,atom,123,{<<1,2>>,[list]}}

सूचियाँ

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

1> [1,2,3].
[1,2,3]
2> [wow,1,{a,b}].     
[wow,1,{a,b}]

सूची का प्रमुख सूची का पहला तत्व है।

सूची की पूंछ सूची के शेष (सिर के बिना) है। यह एक सूची भी है।
आप सूची का प्रमुख और पूंछ प्राप्त करने के लिए hd/1 और tl/1 उपयोग कर सकते हैं या [H|T] से मिलान कर सकते हैं।

3> hd([1,2,3]).
1
4> tl([1,2,3]).
[2,3]
5> [H|T] = [1,2,3].
[1,2,3]
6> H.
1
7> T.
[2,3]

किसी सूची में एक तत्व को प्रस्तुत करना

8> [new | [1,2,3]].
[new,1,2,3]

संबंधित सूची

9> [concat,this] ++ [to,this].
[concat,this,to,this]

स्ट्रिंग्स

एरलैंग में, स्ट्रिंग्स एक अलग डेटा प्रकार नहीं हैं: वे ASCII या यूनिकोड कोड बिंदुओं का प्रतिनिधित्व करने वाले पूर्णांकों की सूची हैं:

> [97,98,99].
"abc"
> [97,98,99] =:= "abc".
true
> hd("ABC").
65

जब एरलैंग शेल एक सूची को प्रिंट करने जा रहा है, तो यह अनुमान लगाने की कोशिश करता है कि क्या वास्तव में आपका मतलब एक स्ट्रिंग था। आप shell:strings(false) को कॉल करके उस व्यवहार को बंद कर सकते हैं shell:strings(false) :

> [8].
"\b"
> shell:strings(false).
true
> [8].
[8]

उपरोक्त उदाहरण में, पूर्णांक 8 को बैकस्पेस के लिए ASCII नियंत्रण चरित्र के रूप में व्याख्या की गई है, जिसे शेल एक स्ट्रिंग में "मान्य" वर्ण मानता है।

प्रोसेसर्स आइडेंटिफ़ायर (Pid)

एर्लैंग की प्रत्येक प्रक्रिया में एक प्रक्रिया पहचानकर्ता ( Pid ) होती है इस प्रारूप में <xxx> , x एक प्राकृतिक संख्या है। नीचे एक Pid का उदाहरण दिया गया है

<0.1252.0>

Pid का उपयोग 'bang' ( ! ) का उपयोग करके प्रक्रिया को संदेश भेजने के लिए किया जा सकता है, Pid को एक चर में Pid जा सकता है, दोनों को नीचे दिखाया गया है

MyProcessId = self().
MyProcessId ! {"Say Hello"}.

इरलांग में प्रक्रियाओं के बारे में और सामान्य रूप से प्रक्रियाओं के बारे में अधिक पढ़ें

funs

एरलंग एक कार्यात्मक प्रोग्रामिंग भाषा है। एक फ़ंक्शन प्रोग्रामिंग भाषा में सुविधाओं में से एक डेटा (कार्यात्मक ऑब्जेक्ट) के रूप में कार्यों को संभाल रहा है।

• किसी फ़ंक्शन को किसी अन्य फ़ंक्शन के तर्क के रूप में पास करें।
• फ़ंक्शन के परिणामस्वरूप फ़ंक्शन लौटाएं।
• कुछ डेटा संरचना में फ़ंक्शन पकड़ो।

एरलंग में उन कार्यों को फन कहा जाता है। फ़न गुमनाम कार्य हैं।

1> Fun = fun(X) -> X*X end.
#Fun<erl_eval.6.52032458>
2> Fun(5).
25

फंड में कई खंड भी हो सकते हैं।

3> AddOrMult = fun(add,X) -> X+X;
3>                (mul,X) -> X*X 
3> end.
#Fun<erl_eval.12.52032458>
4> AddOrMult(mul,5).
25
5> AddOrMult(add,5).
10

आप सिंटैक्स के साथ fun Module:Function/Arity रूप में भी मॉड्यूल कार्यों का उपयोग कर सकते हैं: fun Module:Function/Arity ।
उदाहरण के लिए, फ़ंक्शन मॉड्यूल को lists मॉड्यूल से max लेने देता है, जिसमें 1 एरिटी है।

6> Max = fun lists:max/1.
#Fun<lists.max.1>
7> Max([1,3,5,9,2]). 
9

मैप्स

एक नक्शा एक सहयोगी सरणी या शब्दकोश है (कुंजी, मूल्य) जोड़े से बना।

1> M0 = #{}.
#{}
2> M1 = #{ "name" => "john", "age" => "28" }.
#{"age" => "28","name" => "john"}
3> M2 = #{ a => {M0, M1} }.
#{a => {#{},#{"age" => "28","name" => "john"}}}

नक्शा अपडेट करने के लिए:

1> M = #{ 1 => x }.
2> M#{ 1 => c }.
#{1 => c}
3> M.
#{1 => x}

केवल कुछ मौजूदा कुंजी अपडेट करें:

1> M = #{ 1 => a, 2 => b}.
2> M#{ 1 := c, 2:= d }.
#{1 => c,2 => d}
3> M#{ 3 := c }.
** exception error: {badkey,3}

पैटर्न मिलान:

1> M = #{ name => "john", age => 28 }.
2> #{ name := Name, age := Age } = M.
3> Name.
"john"
4> Age.
28

बिट सिंटैक्स: डिफॉल्ट्स

बिट सिंटैक्स पर एरलंग डॉक का स्पष्टीकरण:

4.4 चूक

[शुरुआत से चूक: << 3.14 >> कानूनी वाक्यविन्यास भी नहीं है।]

डिफ़ॉल्ट आकार प्रकार पर निर्भर करता है। पूर्णांक के लिए यह है 8. फ्लोट के लिए यह 64 है। बाइनरी के लिए यह निर्दिष्ट बाइनरी का वास्तविक आकार है:

    1> Bin = << 17/integer, 3.2/float, <<97, 98, 99>>/binary >>. 
    <<17,64,9,153,153,153,153,153,154,97,98,99>>
      ^ |<-------------------------->|<------>|
      |            float=64           binary=24
  integer=8


    2> size(Bin). % Returns the number of bytes:
    12            % 8 bits + 64 bits + 3*8 bits = 96 bits => 96/8 = 12 bytes

मिलान में, आकार के बिना एक द्विआधारी खंड को केवल पैटर्न के अंत में अनुमति दी जाती है, और डिफ़ॉल्ट आकार मैच के दाहिने हाथ पर बाइनरी के बाकी है:

25> Bin = <<97, 98, 99>>. 
<<"abc">>

26> << X/integer, Rest/binary >> = Bin. 
<<"abc">>

27> X. 
97

28> Rest. 
<<"bc">>

एक पैटर्न में बाइनरी के साथ अन्य सभी खंडों में एक आकार निर्दिष्ट करना चाहिए:

12> Bin = <<97, 98, 99, 100>>.         
<<"abcd">>

13> << B:1/binary, X/integer, Rest/binary >> = Bin. %'unit' defaults to 8 for  
<<"abcd">>                    %binary type, total segment size is Size * unit  

14> B.
<<"a">>

15> X.
98

16> Rest.
<<"cd">>

17> << B2/binary, X2/integer, Rest2/binary >> = Bin. 
* 1: a binary field without size is only allowed at the end of a binary pattern