Elixir Language
कार्य

अनाम कार्य

अमृत में, एक सामान्य अभ्यास अनाम कार्यों का उपयोग करना है। एक अनाम फ़ंक्शन बनाना सरल है:

iex(1)> my_func = fn x -> x * 2 end
#Function<6.52032458/1 in :erl_eval.expr/5>

सामान्य वाक्यविन्यास है:

fn args -> output end

पठनीयता के लिए, आप तर्क के आसपास कोष्ठक डाल सकते हैं:

iex(2)> my_func = fn (x, y) -> x*y end
#Function<12.52032458/2 in :erl_eval.expr/5>

एक अनाम फ़ंक्शन को लागू करने के लिए, इसे असाइन किए गए नाम से कॉल करें और जोड़ें . नाम और तर्कों के बीच।

iex(3)>my_func.(7, 5)
35

तर्क के बिना अनाम कार्यों की घोषणा करना संभव है:

iex(4)> my_func2 = fn -> IO.puts "hello there" end
iex(5)> my_func2.()
hello there
:ok

कैप्चर ऑपरेटर का उपयोग करना

अनाम कार्यों को अधिक संक्षिप्त बनाने के लिए आप कैप्चर ऑपरेटर & उपयोग कर सकते हैं। उदाहरण के लिए, इसके बजाय:

iex(5)> my_func = fn (x) -> x*x*x end

तुम लिख सकते हो:

iex(6)> my_func = &(&1*&1*&1)

कई मापदंडों के साथ, प्रत्येक तर्क के अनुरूप संख्या का उपयोग करें, 1 से गिनती:

iex(7)> my_func = fn (x, y) -> x + y end

iex(8)> my_func = &(&1 + &2)   # &1 stands for x and &2 stands for y

iex(9)> my_func.(4, 5)
9

एकाधिक शरीर

एक अनाम फ़ंक्शन में कई निकाय भी हो सकते हैं ( पैटर्न मिलान के परिणामस्वरूप):

my_func = fn
  param1 -> do_this
  param2 -> do_that
end

जब आप कई निकायों के साथ एक फ़ंक्शन कहते हैं, तो अमृत आपके द्वारा प्रदान किए गए मापदंडों से मेल खाने का प्रयास करता है।

कीवर्ड सूची फ़ंक्शन मापदंडों के रूप में सूचीबद्ध होती है

'विकल्प'-शैली के मापदंडों के लिए कीवर्ड सूचियों का उपयोग करें जिसमें कई कुंजी-मूल्य जोड़े हैं:

def myfunc(arg1, opts \\ []) do
  # Function body
end

हम ऊपर दिए गए फ़ंक्शन को कॉल कर सकते हैं:

iex> myfunc "hello", pizza: true, soda: false

जो इसके बराबर है:

iex> myfunc("hello", [pizza: true, soda: false])

तर्क मान क्रमशः opts.pizza और opts.soda रूप में उपलब्ध हैं।
वैकल्पिक रूप से, आप परमाणुओं का उपयोग कर सकते हैं: opts[:pizza] और opts[:soda] ।

नामित कार्य और निजी कार्य

नाम दिया गया कार्य

defmodule Math do
    # one way
    def add(a, b) do
        a + b
    end

    # another way
    def subtract(a, b), do: a - b
end

iex> Math.add(2, 3)
5
:ok
iex> Math.subtract(5, 2)
3
:ok

निजी कार्य

defmodule Math do
    def sum(a, b) do
        add(a, b)
    end

    # Private Function
    defp add(a, b) do
        a + b
    end
end

iex> Math.add(2, 3)
** (UndefinedFunctionError) undefined function Math.add/2
Math.add(3, 4)
iex> Math.sum(2, 3)
5

पैटर्न मिलान

अमृत अपने तर्कों के मूल्य के आधार पर अपने शरीर के लिए एक फ़ंक्शन कॉल से मेल खाता है।

defmodule Math do
    def factorial(0): do: 1
    def factorial(n): do: n * factorial(n - 1)
end

यहां, सकारात्मक संख्याओं का गुट दूसरे खंड से मेल खाता है, जबकि factorial(0) पहले से मेल खाता है। (सादगी के लिए नकारात्मक संख्या की अनदेखी)। अमृत ऊपर से नीचे तक के कार्यों का मिलान करने की कोशिश करता है। यदि दूसरा फ़ंक्शन पहले से ऊपर लिखा गया है, तो हम एक अप्रत्याशित परिणाम प्राप्त करेंगे क्योंकि यह एक अंतहीन पुनरावृत्ति के लिए जाता है। क्योंकि factorial(0) से factorial(n) से मेल खाता है

गार्ड क्लॉस

गार्ड क्लॉज़ हमें फ़ंक्शन को निष्पादित करने से पहले तर्कों की जांच करने में सक्षम बनाता है। गार्ड क्लॉस को आमतौर पर if उनकी पठनीयता के कारण और cond के लिए पसंद किया जाता है, और संकलक के लिए एक निश्चित अनुकूलन तकनीक को आसान बनाने के लिए पसंद किया जाता है। पहला फ़ंक्शन परिभाषा जहां सभी गार्ड मैच निष्पादित होते हैं।

यहां गार्ड और पैटर्न मिलान का उपयोग करके फैक्टरियल फ़ंक्शन का एक उदाहरण कार्यान्वयन है।

defmodule Math do
    def factorial(0), do: 1
    def factorial(n) when n > 0: do: n * factorial(n - 1)
end

पहला पैटर्न मेल खाता है यदि (और केवल अगर) तर्क 0 । यदि तर्क 0 नहीं है, तो पैटर्न मिलान विफल हो जाता है और नीचे अगला फ़ंक्शन चेक किया जाता है।

उस दूसरे फ़ंक्शन की परिभाषा में एक गार्ड क्लॉज है: when n > 0 । इसका मतलब है कि यह फ़ंक्शन केवल तभी मेल खाता है जब तर्क n 0 से अधिक है। आखिरकार, गणितीय पूर्णांक फ़ंक्शन नकारात्मक पूर्णांक के लिए परिभाषित नहीं है।

यदि न तो फ़ंक्शन की परिभाषा (उनके पैटर्न मिलान और गार्ड क्लॉस सहित) मैच, तो एक FunctionClauseError उठाया जाएगा। यह इस फ़ंक्शन के लिए होता है जब हम एक नकारात्मक संख्या को तर्क के रूप में पास करते हैं, क्योंकि यह नकारात्मक संख्याओं के लिए परिभाषित नहीं है।

ध्यान दें कि यह FunctionClauseError ही, एक गलती नहीं है। रिटर्निंग -1 या 0 या कुछ अन्य "एरर वैल्यू" जैसा कि कुछ अन्य भाषाओं में आम है, इस तथ्य को छिपाएगा कि आपने एक अपरिभाषित फ़ंक्शन को कहा, त्रुटि के स्रोत को छिपाते हुए, संभवतः भविष्य के डेवलपर के लिए एक विशाल दर्दनाक बग बना रहा है।

डिफ़ॉल्ट पैरामीटर

आप किसी भी नामित फ़ंक्शन को सिंटैक्स का उपयोग करके डिफ़ॉल्ट पैरामीटर पास कर सकते हैं: param \\ value :

defmodule Example do
    def func(p1, p2 \\ 2) do
        IO.inspect [p1, p2]
    end
end

Example.func("a")    # => ["a", 2]
Example.func("b", 4) # => ["b", 4]

कार्यों पर कब्जा

का प्रयोग करें & अन्य मॉड्यूल से कार्यों पर कब्जा करने की। आप कैप्चर किए गए फ़ंक्शंस को सीधे फंक्शन पैरामीटर्स के रूप में या अनाम फ़ंक्शंस के भीतर उपयोग कर सकते हैं।

Enum.map(list, fn(x) -> String.capitalize(x) end)

अधिक का उपयोग करते हुए संक्षिप्त बनाया जा सकता है & :

Enum.map(list, &String.capitalize(&1))

किसी भी तर्क को पारित किए बिना कार्यों को कैप्चर करने के लिए आपको स्पष्ट रूप से अपनी &String.capitalize/1 , जैसे &String.capitalize/1 को निर्दिष्ट करने की आवश्यकता होती है:

defmodule Bob do
  def say(message, f \\ &String.capitalize/1) do
    f.(message)
  end
end