क्या आप जानते हैं कि सही रूबी मेथड का उपयोग करना आपका बहुत सारा काम बचा सकता है?
आप जितने अधिक मेथड्स से परिचित होंगे उतनी ही तेजी से आप कार्यशील कोड बना सकते हैं और यह कोड प्रदर्शन और गुणवत्ता दोनों में बेहतर होगा।
यही कारण है कि आज मैं आपको 7 दिलचस्प मेथड्स से परिचित कराना चाहता हूँ जिन्हें आपने पहले नहीं देखा होगा।
विषयसूची
- 1 Integer#digits मेथड (रूबी 2.4)
- 2 Tap मेथड
- 3 Array#values_at
- 4 Hash#transform_values (रूबी 2.4)
- 5 Kernel#itself (रूबी 2.2)
- 6 Array#count
- 7 Enumerable#cycle
- 8 सारांश
- 8.1 संबंधित
Integer#digits मेथड (रूबी 2.4)
यह रूबी 2.4 में पेश किया गया एक नया मेथड है और यदि आप एक Integer के व्यक्तिगत अंकों के साथ काम करना चाहते हैं तो यह बहुत उपयोगी है।
नोट: यदि आप रूबी 2.4 परिवर्तनों पर अपडेट नहीं हैं, तो Fixnum और Bignum अब डिप्रेकेटेड हैं और दोनों Integer में मर्ज हो गए हैं।
आप सोच सकते हैं कि सरणी-जैसी इंडेक्सिंग काम कर सकती है:
2[0] # 0 2[1] # 1
लेकिन जो आपको मिलते हैं वे अंक नहीं हैं, बल्कि बाइनरी बिट्स हैं जो इस संख्या को बनाते हैं।
तो pre-digits मेथड का सामान्य समाधान संख्या को स्ट्रिंग में बदलना था, फिर chars मेथड का उपयोग करके उस स्ट्रिंग को वर्णों की सरणी में तोड़ना, और अंत में हर स्ट्रिंग को वापस इंटीजर में बदलना।
उदाहरण:
123.to_s.chars.map(&:to_i).reverse # [3, 2, 1]
लेकिन पोस्ट-digits मेथड दुनिया में, आप बस यह कर सकते हैं:
123.digits # [3, 2, 1]
बहुत बेहतर, है ना?
वीडियो:
Tap मेथड
कभी-कभी आप एक ऑब्जेक्ट बनाना चाहते हैं, उस पर कुछ मेथड्स कॉल करना चाहते हैं और वही ऑब्जेक्ट लौटाना चाहते हैं।
आपको ऐसा कुछ करना होगा:
user = User.new user.name = "John" user
समस्या यह है कि हमें इस अस्थायी वेरिएबल से निपटना पड़ता है।
यहाँ tap मेथड बचाव के लिए आता है!
tap के साथ अंतिम उदाहरण यह बन जाता है:
User.new.tap { |user| user.name = "John" } ध्यान दें कि अस्थायी वेरिएबल चला गया है, जो एक अच्छी बात है 🙂
Array#values_at
यदि आप किसी सरणी या हैश से कई गैर-अनुक्रमिक मान प्राप्त करना चाहते हैं तो आप यह कर सकते हैं:
arr = [1,2,3,4,5] a, b, c = arr[0], arr[1], arr[4]
या आप values_at मेथड का उपयोग कर सकते हैं:
arr = [1,2,3,4,5] a, b, c = arr.values_at(0, 1, 4)
यह हैश के साथ भी काम करता है:
hash = {bacon: 300, chocolate: 200} p hash.values_at(:bacon, :chocolate) # [300, 200] Hash#transform_values (रूबी 2.4)
मान लीजिए आपके पास एक हैश है और आप किसी कारण से सभी मानों को बदलना चाहते हैं।
कुछ वैसा ही जैसा आप Array#map के साथ करेंगे।
map के साथ समस्या यह है कि आपको सरणी-की-सरणी (बहुआयामी सरणी) मिलेगी बजाय हैश के। इसके अलावा कोई Hash#map! नहीं है।
तो एक समाधान यह हो सकता है:
h = {bacon: 200, coconut: 300} h.each { |k,v| h[k] = v*2 } इस उदाहरण में हम प्रत्येक मान को दो से गुणा करते हैं।
जिसके परिणामस्वरूप:
{:bacon=>400, :coconut=>600} रूबी 2.4 से इसे करने का एक बेहतर तरीका है:
h.transform_values! { |v| v * 2 } यह रेल्स से आने वाले उन मेथड्स में से एक है, जो अब फ्रेमवर्क के बाहर उपलब्ध है 🙂
Kernel#itself (रूबी 2.2)
यदि आपने मुझे बताया कि यह मेथड पहली नज़र में बहुत दिलचस्प नहीं लगता तो मैं आपसे सहमत होऊंगा।
लेकिन कारण यह है कि आपको कुछ अच्छे उदाहरण देखने की जरूरत है।
तो मान लीजिए हमारे पास दोहराए गए शब्दों वाली एक सरणी है और हम उन्हें गिनना चाहते हैं…
हालांकि ऐसा करने के कई तरीके हैं, मुझे लगता है कि यह हमारे नए दोस्त: Kernel#itself को टेस्ट करने के लिए एक बढ़िया केस है।
उदाहरण:
words = %w(cat cat tiger dog cat) words.group_by(&:itself).transform_values(&:size)
ध्यान दें कि मैंने इसे Hash#transform_values के साथ भी जोड़ा है!
यदि transform_values उपलब्ध नहीं है तो आप यह कर सकते हैं:
words .group_by(&:itself) .each_with_object({}) { |(k,v), hash| hash[k] = v.size } वीडियो:
नोट: itself मेथड डॉक्यूमेंटेशन में Object क्लास के तहत दिखाई देता है, लेकिन मेथड Kernel मॉड्यूल पर परिभाषित है।
Array#count
कभी-कभी आपको बस कुछ गिनने की जरूरत होती है।
ठेठ काउंटर + लूप का उपयोग करने के बजाय आप count मेथड का उपयोग कर सकते हैं!
उदाहरण:
letters = %w(a a a b c d a) letters.count("a") # 4 इस मेथड का सरणी संस्करण एक ब्लॉक भी लेता है, ताकि आप अधिक जटिल गिनती कर सकें।
numbers = [1,2,3,4,5,6] numbers.count(&:even?) # 3
वीडियो:
Enumerable#cycle
क्या आप कुछ पैटर्न दोहराना चाहते हैं? या शायद आपको एक आसान ऑन/ऑफ टॉगल चाहिए?
तो Enumerable#cycle वही हो सकता है जिसे आप ढूंढ रहे हैं!
उदाहरण:
array = %w(a b c) # Same as array * 3 array.cycle(3).to_a
लेकिन cycle के लिए मेरा पसंदीदा उपयोग "स्विच" या "टॉगल" ऑब्जेक्ट बनाना है।
switch = %w(on off).cycle switch.next
इसके बारे में अच्छी बात यह है कि आपको स्विच के वर्तमान मान की जांच करके इसे मैन्युअली अपडेट करने की आवश्यकता नहीं है।
आप बस next कॉल कर सकते हैं और रूबी को ठीक-ठीक पता होगा कि क्या करना है 🙂
सारांश
आपने कुछ नए उपयोगी मेथड्स के बारे में सीखा: Integer#digits, Kernel#tap, Array#values_at, Hash#transform_values, Kernel#itself, Array#count, Enumerable#cycle।
यदि आप पहले से ही इनके बारे में जानते थे तो बहुत बढ़िया! यदि नहीं तो मुझे उम्मीद है कि आप इन्हें उपयोगी पाएंगे 🙂
लेख पसंद आया? तो इसे अपने दोस्तों के साथ शेयर करें ताकि वे भी इसका आनंद ले सकें!
