अमृत - Enumerables

एक enumerable एक ऐसी वस्तु है जिसे enumerated किया जा सकता है। "एनुमरेटेड" का अर्थ है एक सेट / संग्रह / श्रेणी के सदस्यों को एक-एक करके (आमतौर पर क्रम में, आमतौर पर नाम से) गिनना।

अमृत उनके साथ काम करने के लिए प्रगणकों और Enum मॉड्यूल की अवधारणा प्रदान करता है। Enum मॉड्यूल में फ़ंक्शन सीमित हैं, जैसा कि नाम से पता चलता है, डेटा संरचनाओं में मूल्यों की गणना करता है। एक enumerable डेटा संरचना का उदाहरण एक सूची, टपल, नक्शा, आदि है। Enum मॉड्यूल हमें 100 से अधिक कार्यों के साथ एनमों से निपटने के लिए प्रदान करता है। हम इस अध्याय में कुछ महत्वपूर्ण कार्यों पर चर्चा करेंगे।

ये सभी कार्य पहले तत्व के रूप में और दूसरे के रूप में एक फ़ंक्शन के रूप में एक enumerable लेते हैं और उन पर काम करते हैं। कार्यों का वर्णन नीचे दिया गया है।

सब?

जब हम उपयोग करते हैं all? फ़ंक्शन, पूरे संग्रह को सही का मूल्यांकन करना चाहिए अन्यथा झूठे को वापस कर दिया जाएगा। उदाहरण के लिए, यह जांचने के लिए कि सूची के सभी तत्व विषम संख्या में हैं, तो।

res = Enum.all?([1, 2, 3, 4], fn(s) -> rem(s,2) == 1 end) 
IO.puts(res)

जब उपरोक्त कार्यक्रम चलाया जाता है, तो यह निम्नलिखित परिणाम उत्पन्न करता है -

false

ऐसा इसलिए है क्योंकि इस सूची के सभी तत्व विषम नहीं हैं।

कोई भी?

जैसा कि नाम से पता चलता है, यह फ़ंक्शन सही है यदि संग्रह का कोई भी तत्व सत्य का मूल्यांकन करता है। उदाहरण के लिए -

res = Enum.any?([1, 2, 3, 4], fn(s) -> rem(s,2) == 1 end)
IO.puts(res)

true

टुकड़ा

यह फ़ंक्शन हमारे संग्रह को दूसरे तर्क के रूप में प्रदान किए गए आकार के छोटे हिस्से में विभाजित करता है। उदाहरण के लिए -

res = Enum.chunk([1, 2, 3, 4, 5, 6], 2)
IO.puts(res)

[[1, 2], [3, 4], [5, 6]]

से प्रत्येक

एक नए मूल्य का उत्पादन किए बिना एक संग्रह पर पुनरावृति करना आवश्यक हो सकता है, इस मामले के लिए हम उपयोग करते हैं each कार्य -

Enum.each(["Hello", "Every", "one"], fn(s) -> IO.puts(s) end)

Hello
Every
one

नक्शा

प्रत्येक आइटम के लिए हमारे फ़ंक्शन को लागू करने और एक नया संग्रह बनाने के लिए हम मानचित्र फ़ंक्शन का उपयोग करते हैं। यह कार्यात्मक प्रोग्रामिंग में सबसे उपयोगी निर्माणों में से एक है क्योंकि यह काफी अभिव्यंजक और छोटा है। इसे समझने के लिए एक उदाहरण पर विचार करते हैं। हम एक सूची में संग्रहीत मानों को दोगुना करेंगे और इसे एक नई सूची में संग्रहीत करेंगेres -

res = Enum.map([2, 5, 3, 6], fn(a) -> a*2 end)
IO.puts(res)

[4, 10, 6, 12]

कम करना

reduceफ़ंक्शन हमें एक मूल्य के लिए हमारे गणना करने में मदद करता है। ऐसा करने के लिए, हम अपने फ़ंक्शन में पारित होने के लिए एक वैकल्पिक संचायक (इस उदाहरण में 5) की आपूर्ति करते हैं; यदि कोई संचायक प्रदान नहीं किया जाता है, तो पहले मूल्य का उपयोग किया जाता है -

res = Enum.reduce([1, 2, 3, 4], 5, fn(x, accum) -> x + accum end)
IO.puts(res)

संचायक प्रारंभिक मान है जिसे पास किया गया है fn। दूसरी कॉल के बाद पिछली कॉल से लौटाए गए मान को संचित के रूप में पारित किया जाता है। हम संचायक के बिना भी कम उपयोग कर सकते हैं -

res = Enum.reduce([1, 2, 3, 4], fn(x, accum) -> x + accum end)
IO.puts(res)

uniq

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

res = Enum.uniq([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
IO.puts(res)

जब प्रोग्राम के ऊपर चल रहा है, यह निम्नलिखित परिणाम पैदा करता है -

[1, 2, 3, 4]

ईगर मूल्यांकन

Enum मॉड्यूल में सभी फ़ंक्शन उत्सुक हैं। कई कार्यों से उम्मीद की जा सकती है और एक सूची वापस आ जाएगी। इसका मतलब यह है कि एनम के साथ कई ऑपरेशन करते समय, प्रत्येक ऑपरेशन एक मध्यवर्ती सूची उत्पन्न करने वाला होता है जब तक कि हम परिणाम तक नहीं पहुंच जाते। आइए इसे समझने के लिए निम्नलिखित उदाहरण पर विचार करें -

odd? = &(odd? = &(rem(&1, 2) != 0) 
res = 1..100_000 |> Enum.map(&(&1 * 3)) |> Enum.filter(odd?) |> Enum.sum 
IO.puts(res)

7500000000

ऊपर के उदाहरण में संचालन की एक पाइपलाइन है। हम एक सीमा के साथ शुरू करते हैं और फिर 3 में प्रत्येक तत्व को 3 से गुणा करते हैं। यह पहला ऑपरेशन अब 100_000 आइटम के साथ एक सूची बनाएगा और वापस करेगा। फिर हम सूची से सभी विषम तत्वों को रखते हैं, एक नई सूची बनाते हैं, अब 50_000 वस्तुओं के साथ, और फिर हम सभी प्रविष्टियों को जोड़ते हैं।

|> ऊपर दिए गए स्निपेट में प्रयुक्त प्रतीक है pipe operator: यह बस इसके बायीं ओर की अभिव्यक्ति से आउटपुट लेता है और इसे दायीं ओर फ़ंक्शन कॉल के पहले तर्क के रूप में पास करता है। यह यूनिक्स के समान है ऑपरेटर। इसका उद्देश्य कार्यों की एक श्रृंखला द्वारा परिवर्तित किए जा रहे डेटा के प्रवाह को उजागर करना है।

के बिना pipe ऑपरेटर, कोड जटिल लग रहा है -

Enum.sum(Enum.filter(Enum.map(1..100_000, &(&1 * 3)), odd?))

हमारे पास कई अन्य कार्य हैं, हालांकि, केवल कुछ महत्वपूर्ण ही यहां वर्णित किए गए हैं।

अमृत ​​- Enumerables

सब?