Elixir Language
सशर्त,

टिप्पणियों

unless false, do: IO.puts("Condition is false")
# Outputs "Condition is false"

# With an `else`:
if false, do: IO.puts("Condition is true"), else: IO.puts("Condition is false")
# Outputs "Condition is false"

मामला

 case {1, 2} do
  {3, 4} ->
    "This clause won't match."
  {1, x} ->
    "This clause will match and bind x to 2 in this clause."
  _ ->
    "This clause would match any value."
end

case केवल विशेष डेटा के दिए गए पैटर्न से मेल खाने के लिए उपयोग किया जाता है। यहां, {1,2} विभिन्न केस पैटर्न के साथ मेल खा रहा है जो कोड उदाहरण में दिया गया है।

अगर और जब तक

if true do
    "Will be seen since condition is true."
end    

if false do
    "Won't be seen since condition is false."
else
    "Will be seen.
end

unless false do
    "Will be seen."
end

unless true do 
    "Won't be seen."
else
    "Will be seen."
end

cond

cond do 
   0 == 1 -> IO.puts "0 = 1"
   2 == 1 + 1 -> IO.puts "1 + 1 = 2" 
   3 == 1 + 2 -> IO.puts "1 + 2 = 3" 
end

# Outputs "1 + 1 = 2" (first condition evaluating to true)

cond एक बढ़ा देंगे CondClauseError अगर कोई शर्त सही हैं।

cond do
  1 == 2 -> "Hmmm"
  "foo" == "bar" -> "What?"
end
# Error

इसे ऐसी शर्त से जोड़ा जा सकता है जो हमेशा सच होगी।

cond do
  ... other conditions
  true -> "Default value"
end

जब तक कि डिफ़ॉल्ट मामले तक पहुंचने की उम्मीद नहीं की जाती है, और कार्यक्रम को वास्तव में उस बिंदु पर दुर्घटनाग्रस्त होना चाहिए।

खंड के साथ

क्लॉज़ के with मैचिंग क्लॉज़ को संयोजित करने के लिए उपयोग किया जाता है। ऐसा लगता है कि हम कई निकायों के साथ अनाम फ़ंक्शन या हैंडल फ़ंक्शन को जोड़ते हैं (मिलान खंड)। मामले पर विचार करें: हम एक उपयोगकर्ता बनाते हैं, उसे DB में सम्मिलित करते हैं, फिर ग्रीटिंग ईमेल बनाते हैं और फिर उसे उपयोगकर्ता को भेजते हैं।

बिना with खंड हम कुछ इस तरह लिख सकते हैं (मैं कार्यों कार्यान्वयन छोड़े गए):

case create_user(user_params) do
  {:ok, user} ->
    case Mailer.compose_email(user) do
      {:ok, email} ->
        Mailer.send_email(email)
      {:error, reason} ->
        handle_error
    end
  {:error, changeset} ->
    handle_error
end

यहाँ हम साथ हमारे व्यापार प्रक्रिया के प्रवाह को संभालने case (यह हो सकता है cond या if )। यह हमें तथाकथित 'कयामत के पिरामिड' की ओर ले जाता है, क्योंकि हमें संभावित परिस्थितियों से निपटना है और यह तय करना है: आगे बढ़ना है या नहीं। यह के साथ इस कोड को फिर से लिखने के लिए बहुत कुछ अच्छा होगा with बयान:

with {:ok, user} <- create_user(user_params),
     {:ok, email} <- Mailer.compose_email(user) do
  {:ok, Mailer.send_email}
else
  {:error, _reason} ->
    handle_error
end

कोड में स्निपेट के ऊपर हम फिर से लिखने नेस्टेड है case के साथ खंड with । भीतर with हम अपने आउटपुट पर कुछ कार्यों (या तो गुमनाम या नाम) और पैटर्न मैच आह्वान। यदि सभी मिलान, with वापसी do ब्लॉक परिणाम, या else अन्यथा ब्लॉक परिणाम।

हम छोड़ सकते हैं else तो with वापसी या तो होगा do ब्लॉक परिणाम या पहले असफल परिणाम।

तो, के मूल्य के with बयान अपनी है do ब्लॉक परिणाम।