एर्लैंग अपनी क्षमताओं में एक अनूठा मंच है, और इसके बावजूद, भाषा अभी भी विदेशी है। इसके कई कारण हैं। उदाहरण के लिए, तंग अंकगणित, असामान्य वाक्यविन्यास, कार्यक्षमता। ये दोष नहीं हैं। ये केवल ऐसी चीजें हैं जो अधिकांश प्रोग्रामर काम नहीं कर सकते हैं या नहीं करना चाहते हैं।
कुछ दिनों पहले, जोस वालिम ने अपनी
रिपॉजिटरी में एरलंग के ऊपर बनी एक भाषा के लिए एक प्रोजेक्ट प्रकाशित किया था। इस भाषा का एक सरल ऑब्जेक्ट मॉडल और रूबी जैसा सिंटैक्स है। कट-ऑफ प्रेस डॉक्यूमेंटेशन के तहत और एक साधारण उदाहरण दिखाने वाला वीडियो।
अस्वीकरण:% उपयोगकर्ता नाम%, अमृत के बारे में निष्कर्ष निकालने से पहले और क्या नहीं कर सकता, कृपया कम से कम रीडमी के माध्यम से एक नज़र डालें।अमृत एक प्रोग्रामिंग भाषा है जो एरलांग के ऊपर चलती है। एरलैंग की तरह, यह कठोर कंप्यूटिंग, वन-टाइम असाइनमेंट और डायनामिक टाइपिंग के साथ एक कार्यात्मक भाषा है, जो वितरित, फॉल्ट-टॉलरेंट, नॉन-स्टॉप, हॉट-स्वैपेबल एप्लिकेशन का समर्थन करने के लिए डिज़ाइन की गई है। Elixir आपको डेटा प्रकारों को परिवर्तित करने की आवश्यकता के बिना Erlang मॉड्यूल को कॉल करने की अनुमति देता है, इसलिए Erlang कोड को कॉल करते समय कोई प्रदर्शन जुर्माना नहीं है।
Elixir और Erlang के बीच मुख्य अंतर सिंटैक्स और ऑब्जेक्ट ओरिएंटेशन है। अमृत एक बहुत ही सरल वस्तु मॉडल और वाक्यविन्यास प्रदान करता है, जो ज्यादातर रूबी पर आधारित है।
वर्तमान में, मुख्य कार्य एक मानक पुस्तकालय विकसित करना है। अधिकांश मौजूदा मानक पुस्तकालय स्वयं अमृत में लिखे गए हैं, और आपको इसके विकास में योगदान करने के लिए एरलांग को जानने की आवश्यकता नहीं है। ओटीपी के सिद्धांतों से परिचित होना पर्याप्त होगा।
आरंभ करने के लिए, पहले आपको अपने कंप्यूटर पर रिपॉजिटरी को क्लोन करना होगा, इसे संकलित और सत्यापित करना होगा:
$ git clone https://github.com/josevalim/elixir.git $ cd elixir $ make test $ bin/elixir -v Elixir 0.1.0
एलिक्जिर की टिप्पणियां, एर्लैंग में, "%" द्वारा निरूपित हैं:
% This is a commented line
इसके अलावा, "% =>" अभिव्यक्ति का मूल्य दर्शाता है:
1 + 1
अमृत पूर्णांक और भिन्नात्मक संख्याओं का समर्थन करता है:
2 + 15 % => 17 - 13 * 10 % => -130 1986 - 1985 % => 1 5 / 2 % => 2.5 4 / 2 % => 2.0
जैसे कि रूबी में कोई भी निर्माण एक वस्तु है। हम संख्याओं पर विधियों को कॉल कर सकते हैं:
-1.abs % => 1 5.div(2) % => 2 %surprise ! 1.+(2) % => 3
अमृत में परमाणुओं को प्रतीक (रूबी के रूप में) कहा जाता है। लेकिन सिंटैक्स को लिस्प से उधार लिया जाता है (जोस ने ट्विटर पर यह समझाया कि वह शब्दकोशों में ":" का उपयोग करना चाहता है):
'atom 'Atom 'atom_without_spaces '"Atom with Spaces"
सूची अमृत में सबसे उपयोगी संरचना है (किसी भी अन्य कार्यात्मक भाषा के रूप में), मैं कुछ भी शामिल कर सकता हूं, और इसमें तरीकों का एक सेट है:
% Some list with elements ['atom, 1, 2, 3, { 'some, 'tuple }] % An empty list [] [1, 2, 3].length % => 3 ['a, 'b, 'c][1] % => 'b [1, 2, 3] + [4, 5, 6] % => [1,2,3,4,5,6]
Erlang और Elixir की सूचियाँ लिंक की गई सूचियों के रूप में कार्यान्वित की जाती हैं, इसलिए पूर्व-जोड़ने वाली वस्तुएँ निम्नलिखित की तुलना में बहुत तेज़ हैं:
list = [2,3,4] % Don't do this: [1] + [2,3,4] % => [1,2,3,4] [0,1] + [2,3,4] % => [0,1,2,3,4] % Do this instead: [1|list] % => [1,2,3,4] [0,1|list] % => [0,1,2,3,4]
सूचियों की वास्तविक शक्ति तब होती है जब आप उन्हें कार्यों के साथ उपयोग करते हैं
[1, 2, 3].map do (x) x * 2 end % => [2, 4, 6] [1, 2, 3].foldl 0, do (x, acc) acc + x end % => 6
Erlang में लाइनों को पात्रों की एक सूची द्वारा दर्शाया गया है:
"hello" == [104, 101, 108, 108, 111]
यह महंगा है क्योंकि प्रत्येक चरित्र स्मृति के 8 बाइट्स पर कब्जा करता है (थोड़ा सा नहीं!)। अमृत बराबरी के तार को utf8 बाइनरी स्ट्रिंग्स के रूप में लागू करता है:
% The famous "hello world" string "hello world" % A string converted to its underlying binary: "hello".to_bin % => <<[104, 101, 108, 108, 111]>> % A string converted to a char list: "hello".to_char_list % => [104, 101, 108, 108, 111] % Strings are UTF-8 "Arrow ⇧ up".length % => 10
यह एक महत्वपूर्ण बदलाव है। स्ट्रिंग केवल रूपांतरण की आवश्यकता वाली वस्तुएं हैं:
% Converting a string_from_erlang to Elixir's String String.new string_from_erlang % Where string_from_erlang is either a binary: <<[104, 101, 108, 108, 111]>> % Or a char_list: [104, 101, 108, 108, 111] % Converting a string_from_elixir to Erlang "string_from_elixir".to_bin "string_from_elixir".to_char_list
अंत में, स्ट्रिंग्स इंटरपोलेशन का समर्थन करते हैं:
"string #{'with} interpolation" % => "string with interpolation" "1 + 1 = #{1 + 1}" % => "1 + 1 = 2"
कार्य किसी भी अन्य कार्यात्मक भाषा की तरह, अमृत का एक महत्वपूर्ण हिस्सा हैं। "डू" या "->" का उपयोग करके कार्य बनाए जा सकते हैं:
my_function = do 1 + 2 end my_function() % => 3 another_function = -> 1 * 2 end another_function() % => 2
एरलैंग की तरह, एलिक्सिर पैटर्न मिलान और यूनिट असाइनमेंट का समर्थन करता है।
% Let's bound the variable x to 'foo x = 'foo % Now let's match a tuple with other tuple. % Since x is already bound, we are comparing x with 'baz and it will fail: { x, y } = { 'baz, 'bar } % In this case, we compare 'x with 'foo and it matches. % Since y is unbound, we assign 'bar to it: { x, y } = { 'foo, 'bar } x % => 'foo y % => 'bar [h|t] = [1,2,3] h % => 1 t % => [2,3] % Raises an error because h was already assigned to 1 and 1 does not match 2 [h|t1] = [2,3,4]
Eralng की तरह, पैटर्न मिलान का उपयोग फ़ंक्शन हस्ताक्षर में किया जाता है:
module Math def fibonacci(0) 0 end def fibonacci(1) 1 end def fibonacci(n) fibonacci(n - 1) + fibonacci(n - 2) end end Math.fibonacci(0) % => 0 Math.fibonacci(1) % => 1 Math.fibonacci(3) % => 2 Math.fibonacci(10) % => 55
Erlang विधियों को कॉल करना काफी तुच्छ है:
% Accessing the is_atom BIF from Erlang. % This is the same as `is_atom(foo)` in Erlang. Erlang.is_atom('foo) % => true % Accessing the function delete from module lists. % This is the same as `lists:member(1, [1,2,3])` in Erlang. Erlang.lists.member(1, [1,2,3]) % => true
अमृत वस्तु मॉडल के कुछ पहलू हैं:
- कार्यान्वयन का गतिशील विकल्प - जब विधि को बुलाया जाता है, तो ऑब्जेक्ट खुद ही चुनता है कि किस कोड को निष्पादित करना है
- मिश्रण - वस्तुओं में विधियाँ नहीं होती हैं। सभी तरीकों को मॉड्यूल में पैक किया जाता है जो वस्तुओं में मिलाते हैं।
- एनकैप्सुलेशन - तरीके सार्वजनिक, संरक्षित या निजी हो सकते हैं।
- खुली पुनरावृत्ति - वस्तुओं में एक विशेष चर स्व है, जो आपको कॉल की श्रृंखला को प्रभावित किए बिना ऑब्जेक्ट के अन्य तरीकों को कॉल करने की अनुमति देता है।
- प्रतिबिंब - अमृत रनटाइम पर किसी वस्तु की संरचना को देखने और संशोधित करने में सक्षम है।
object Person def constructor(name, age) end def name @name end def age @age end def name(value) self.set_ivar('name, value) end end person = Person.name('john, 24) another_person = person.name('john_doe) person.name % => 'john person.age % => 24 another_person.name % => 'johh_doe another_person.age % => 24
यह अमृत सुविधाओं के एक छोटे से हिस्से का वर्णन है। रिपॉजिटरी ने उत्कृष्ट अवलोकन
प्रलेखन प्रकाशित किया है। नीचे दिया गया वीडियो इस बात का एक छोटा उदाहरण दिखाता है कि भाषा कैसे काम करती है: