रूबी के Enumerable मॉड्यूल में महारत: एक व्यावहारिक गाइड + मेरा शीर्ष मेथड

Enumerable क्या है?

Enumerable पुनरावृति मेथड्स का एक संग्रह है, एक रूबी मॉड्यूल, और रूबी को एक महान प्रोग्रामिंग भाषा बनाने का एक बड़ा हिस्सा।

Enumerable में सहायक मेथड्स शामिल हैं जैसे:

map
select
inject

Enumerable मेथड्स उन्हें एक ब्लॉक देकर काम करते हैं।

उस ब्लॉक में आप उन्हें बताते हैं कि आप हर एलिमेंट के साथ क्या करना चाहते हैं।

उदाहरण के लिए:

 [1,2,3].map { |n| n * 2 }

यह आपको एक नई सरणी देता है जहां हर नंबर दोगुना हो गया है।

ठीक क्या होता है यह इस बात पर निर्भर करता है कि आप किस मेथड का उपयोग करते हैं, map आपको सभी मानों को बदलने में मदद करता है, select आपको एक सूची को फ़िल्टर करने देता है और inject का उपयोग सरणी के अंदर सभी मानों को जोड़ने के लिए किया जा सकता है।

20 से अधिक रूबी Enumerable मेथड्स हैं।

आइए एक का विस्तार से अध्ययन करें।

Each_Cons मेथड

मेरा नया पसंदीदा Enumerable मेथड each_cons है!

यहाँ क्यों:

यह मेथड वास्तव में उपयोगी है, आप इसका उपयोग n-grams खोजने के लिए या all? के साथ संयुक्त होने पर संख्याओं के अनुक्रम की सन्निकटता जांचने के लिए कर सकते हैं, एक और Enumerable मेथड।

रूबी के Enumerable मॉड्यूल में महारत: एक व्यावहारिक गाइड + मेरा शीर्ष मेथड

each_cons आपको आकार n की उप-सरणियाँ देता है, इसलिए यदि आपके पास [1,2,3] है, तो each_cons(2) आपको [[1,2], [2,3]] देगा।

एक उदाहरण देखते हैं:

 numbers = [3,5,4,2]
numbers.sort.each_cons(2).all? { |x,y| x == y - 1 }

यह कोड संख्याओं को सॉर्ट करके शुरू होता है, फिर each_cons(2) कॉल करता है, जो एक Enumerator ऑब्जेक्ट लौटाता है, और फिर यह जांचने के लिए all? मेथड को कॉल करता है कि क्या सभी एलिमेंट्स शर्त से मेल खाते हैं।

यहां एक और उदाहरण है, जहां मैं each_cons का उपयोग यह जांचने के लिए करता हूं कि क्या कोई वर्ण उसी वर्ण से घिरा हुआ है, जैसे: xyx।

 str = 'abcxyx'
str.chars.each_cons(3).any? { |a,b,c| a == c }

और भी बहुत कुछ है!

यदि आप जानना चाहते हैं कि यह पैटर्न कितनी बार होता है, true / false परिणाम प्राप्त करने के बजाय, आप बस any? को count में बदल सकते हैं।

मुझे जो और भी आकर्षक लगता है वह है each_cons मेथड का कार्यान्वयन।

 array = []
each do |element|
  array << element
  array.shift if array.size > n
  yield array.dup if array.size == n
end

नोट: यह Enumerable के Rubinius कार्यान्वयन से आता है। आप मूल स्रोत कोड यहां पा सकते हैं।

कार्यान्वयन एक खाली रूबी सरणी से शुरू होता है, फिर यह each का उपयोग करके एलिमेंट्स के माध्यम से पुनरावृति करता है।

यहां तक सब कुछ काफी मानक है। लेकिन फिर यह एलिमेंट को सरणी में जोड़ता है और यदि आकार हमारे इच्छित से बड़ा है तो सरणी को ट्रिम करता है (Array#shift का उपयोग करके)।

आकार each_cons का तर्क है।

फिर यह सरणी की एक dup यील्ड करता है यदि सरणी का अनुरोधित आकार है।

मुझे लगता है कि यह प्रतिभाशाली है, क्योंकि यह हमारे एन्यूमरेबल ऑब्जेक्ट में एक 'स्लाइडिंग विंडो' प्रकार का प्रभाव रखता है, बजाय सरणी इंडेक्स के साथ उलझने के।

अधिक आकर्षक मेथड्स

मेथड	विवरण
count	बिल्कुल वही जो नाम कहता है, ब्लॉक के अंदर true मूल्यांकन करने वाली चीजों को गिनें
group_by	ब्लॉक रिटर्न मान द्वारा एन्यूमरेबल एलिमेंट्स को समूहित करें। एक हैश लौटाता है
partition	दो समूहों में विभाजित करें। एक दो-आयामी सरणी लौटाता है
any?	यदि ब्लॉक किसी भी एलिमेंट के लिए `true` लौटाता है तो `true` लौटाता है
all?	यदि ब्लॉक सभी एलिमेंट्स के लिए `true` लौटाता है तो `true` लौटाता है
none?	`all?` का विपरीत
cycle(n)	सभी एलिमेंट्स को n बार दोहराएं, इसलिए यदि आप `[1,2].cycle(2)` करते हैं तो आपके पास `[1,2,1,2]` होगा
find	`select` की तरह, लेकिन यह पहली चीज लौटाता है जो यह पाता है
inject	पिछले ब्लॉक मान के परिणाम को संचित करता है और इसे अगले में पास करता है। योग जोड़ने के लिए उपयोगी
zip	दो एन्यूमरेबल ऑब्जेक्ट्स को एक साथ जोड़ता है, ताकि आप उनके साथ समानांतर में काम कर सकें। एलिमेंट्स की तुलना करने और हैश जनरेट करने के लिए उपयोगी
map	एन्यूमरेबल ऑब्जेक्ट के हर एलिमेंट को बदलता है और नए संस्करण को सरणी के रूप में लौटाता है

समापन

जैसा कि आपने देखा, Enumerable एक मॉड्यूल है जिसमें महारत हासिल करना उचित है, इसलिए डॉक्यूमेंटेशन पर जाएं और देखें कि यह आपके लिए क्या कर सकता है!

यदि आपको यह लेख पसंद आया तो इसे शेयर करना और नीचे दिए गए फॉर्म में मेरे न्यूज़लेटर की सदस्यता लेना न भूलें। इससे मुझे बहुत मदद मिलेगी! 🙂