Elixir Language
ऑपरेटर्स

पाइप ऑपरेटर

पाइप ऑपरेटर |> बाईं ओर एक अभिव्यक्ति का परिणाम लेता है और इसे दाईं ओर एक फ़ंक्शन के पहले पैरामीटर के रूप में खिलाता है।

expression |> function

एक साथ श्रृंखला अभिव्यक्तियों के लिए और कार्यों की एक श्रृंखला के प्रवाह को नेत्रहीन रूप से दस्तावेज करने के लिए पाइप ऑपरेटर का उपयोग करें।

निम्नलिखित को धयान मे रखते हुए:

Oven.bake(Ingredients.Mix([:flour, :cocoa, :sugar, :milk, :eggs, :butter]), :temperature)

उदाहरण में, Oven.bake से पहले आता है Ingredients.mix , लेकिन यह पिछले निष्पादित किया जाता है। इसके अलावा, यह स्पष्ट नहीं हो सकता है कि :temperature Oven.bake का एक पैरामीटर है

पाइप ऑपरेटर का उपयोग करके इस उदाहरण को फिर से लिखना:

[:flour, :cocoa, :sugar, :milk, :eggs, :butter]
|> Ingredients.mix
|> Oven.bake(:temperature)

एक ही परिणाम देता है, लेकिन निष्पादन का क्रम स्पष्ट है। इसके अलावा, यह स्पष्ट है कि :temperature Oven.bake कॉल के लिए :temperature एक पैरामीटर है।

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

Enum.each([1, 2, 3], &(&1+1)) # produces [2, 3, 4]

के समान है:

[1, 2, 3]
|> Enum.each(&(&1+1))

पाइप ऑपरेटर और कोष्ठक

अस्पष्टता से बचने के लिए कोष्ठक की आवश्यकता होती है:

foo 1 |> bar 2 |> baz 3

के रूप में लिखा जाना चाहिए:

foo(1) |> bar(2) |> baz(3)

बूलियन ऑपरेटर्स

अमृत में दो प्रकार के बूलियन ऑपरेटर हैं:

• बूलियन ऑपरेटर (वे अपने पहले तर्क के रूप में true या false उम्मीद करते हैं)

x or y      # true if x is true, otherwise y

x and y     # false if x is false, otherwise y

not x       # false if x is true, otherwise true

बूलियन ऑपरेटरों के सभी ArgumentError को बढ़ाएंगे यदि पहला तर्क कड़ाई से बूलियन मान नहीं होगा, जिसका अर्थ केवल true या false ( nil बूलियन नहीं है)।

iex(1)> false and 1 # return false
iex(2)> false or 1 # return 1 
iex(3)> nil and 1 # raise (ArgumentError) argument error: nil

• आराम से बूलियन ऑपरेटर (किसी भी प्रकार के साथ काम करते हैं, सब कुछ जो न तो false और न ही nil माना जाता true )

x || y     # x if x is true, otherwise y

x && y     # y if x is true, otherwise false

!x         # false if x is true, otherwise true

संचालक || हमेशा पहले तर्क वापस आ जाएगी अगर यह के truthy (सिवाय अमृत व्यवहार करता है सब कुछ nil और false comparisions में सच हो करने के लिए), अन्यथा दूसरा एक वापस आ जाएगी।

iex(1)> 1 || 3 # return 1, because 1 is truthy
iex(2)> false || 3 # return 3
iex(3)> 3 || false # return 3
iex(4)> false || nil # return nil
iex(5)> nil || false # return false

यदि यह सत्य है तो ऑपरेटर && हमेशा दूसरा तर्क लौटाएंगे। अन्यथा तर्कों, false या nil वापस आ जाएगा।

iex(1)> 1 && 3 # return 3, first argument is truthy
iex(2)> false && 3 # return false
iex(3)> 3 && false # return false 
iex(4)> 3 && nil # return nil
iex(5)> false && nil # return false
iex(6)> nil && false # return nil

दोनों && और || शॉर्ट-सर्किट ऑपरेटर हैं। वे केवल सही पक्ष को निष्पादित करते हैं यदि परिणाम को निर्धारित करने के लिए बाईं ओर पर्याप्त नहीं है।

संचालक ! वर्तमान अवधि की उपेक्षा का बूलियन मान लौटाएगा:

iex(1)> !2 # return false
iex(2)> !false # return true
iex(3)> !"Test" # return false
iex(4)> !nil # return true

चयनित अवधि के बूलियन मूल्य प्राप्त करने का सरल तरीका बस इस ऑपरेटर को दोगुना करना है:

iex(1)> !!true # return true
iex(2)> !!"Test" # return true
iex(3)> !!nil # return false
iex(4)> !!false # return false

तुलनात्मक संचालक

समानता:

• मूल्य समानता x == y ( 1 == 1.0 # true )
• मूल्य असमानता x == y ( 1 != 1.0 # false )
• सख्त समानता x === y ( 1 === 1.0 # false )
• सख्त असमानता x === y ( 1 !== 1.0 # true )

तुलना:

• x > y
• x >= y
• x < y
• x <= y

यदि प्रकार संगत हैं, तो तुलना प्राकृतिक आदेश का उपयोग करती है। अन्यथा सामान्य प्रकार के तुलना नियम है:

number < atom < reference < function < port < pid < tuple < map < list < binary

ऑपरेटरों से जुड़ें

आप शामिल हो सकते हैं (संक्षिप्त) बायनेरिज़ (तार सहित) और सूचियाँ:

iex(1)> [1, 2, 3] ++ [4, 5]
[1, 2, 3, 4, 5]

iex(2)> [1, 2, 3, 4, 5] -- [1, 3]
[2, 4, 5]

iex(3)> "qwe" <> "rty"
"qwerty"

'इन' ऑपरेटर

in आप की जाँच करने के ऑपरेटर की अनुमति देता है एक सूची या श्रेणी के लिए एक आइटम शामिल हैं या नहीं:

iex(4)> 1 in [1, 2, 3, 4]
true

iex(5)> 0 in (1..5)
false