रूबी एन्यूमरेबल मॉड्यूल के लिए एक बुनियादी गाइड (+ मेरी पसंदीदा विधि)

एन्यूमरेबल क्या है?

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

एन्यूमरेबल में उपयोगी तरीके शामिल हैं जैसे :

• map
• select
• inject

असंख्य तरीके उन्हें एक ब्लॉक देकर काम करते हैं।

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

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

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

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

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

20 से अधिक रूबी एन्यूमरेबल विधियाँ हैं।

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

प्रत्येक_विपक्ष विधि

मेरा नया पसंदीदा Enumerable विधि है each_cons !

यहां बताया गया है :

यह विधि वास्तव में उपयोगी है, आप इसका उपयोग एन-ग्राम खोजने के लिए या यह जांचने के लिए कर सकते हैं कि all? के साथ संयुक्त होने पर संख्याओं का अनुक्रम सन्निहित है या नहीं। , एक और 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 returns देता है ऑब्जेक्ट, और फिर यह 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 . के रुबिनियस कार्यान्वयन से आता है . आप मूल स्रोत कोड यहां पा सकते हैं।

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

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

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

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

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

अधिक आकर्षक तरीके

रैपिंग अप

जैसा कि आपने देखा, Enumerable एक मॉड्यूल है जो महारत हासिल करने लायक है, इसलिए दस्तावेज़ीकरण पर जाएं और देखें कि यह आपके लिए क्या कर सकता है!

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