क्या आप जानते हैं कि रूबी के सही तरीके का इस्तेमाल करने से आपका बहुत सारा काम बच सकता है?
आप जितनी अधिक विधियों से परिचित होंगे आप उतनी ही तेज़ी से कार्य कोड तैयार कर सकते हैं &प्रदर्शन और गुणवत्ता दोनों में यह कोड बेहतर होगा।
इसलिए आज मैं आपके लिए 7 दिलचस्प तरीके पेश करना चाहता हूं जो आपने पहले नहीं देखे होंगे।
सामग्री
- 1 पूर्णांक # अंक विधि (रूबी 2.4)
- 2 टैप विधि
- 3 सरणी#values_at
- 4 हैश#ट्रांसफॉर्म_वैल्यू (रूबी 2.4)
- 5 कर्नेल#स्वयं (रूबी 2.2)
- 6 सरणी#गिनती
- 7 अगणनीय#चक्र
- 8 सारांश
- 8.1 संबंधित
पूर्णांक#अंक विधि (रूबी 2.4)
यह रूबी 2.4 में पेश की गई एक नई विधि है और यदि आप किसी पूर्णांक के अलग-अलग अंकों के साथ काम करना चाहते हैं तो यह बहुत उपयोगी है।
<ब्लॉकक्वॉट>नोट :यदि आप रूबी 2.4 परिवर्तनों पर गति नहीं कर रहे हैं, तो फिक्सनम और बिग्नम अब बहिष्कृत हैं और दोनों को इंटीजर में विलय कर दिया गया है।
आप सोच सकते हैं कि सरणी जैसी अनुक्रमणिका का उपयोग करना काम कर सकता है :
2[0] # 0 2[1] # 1
लेकिन आपको जो मिलता है वह अंक नहीं, बल्कि बाइनरी बिट्स होते हैं जो इस संख्या को बनाते हैं।
तो प्री-digits विधि सामान्य समाधान संख्या को एक स्ट्रिंग में परिवर्तित करना था, फिर उस स्ट्रिंग को वर्णों की एक सरणी में तोड़ना chars का उपयोग करना था विधि, और अंत में प्रत्येक स्ट्रिंग को एक पूर्णांक में परिवर्तित करें।
उदाहरण :
123.to_s.chars.map(&:to_i).reverse [3, 2, 1]
लेकिन एक पोस्ट में-digits मेथड वर्ल्ड, आप बस यह कर सकते हैं:
123.digits [3, 2, 1]
बहुत बेहतर, है ना?
वीडियो :
द टैप विधि
कभी-कभी आप कोई ऑब्जेक्ट बनाना चाहते हैं, उस पर कुछ विधियों को कॉल करें और उसी ऑब्जेक्ट को वापस करें।
आपको कुछ ऐसा करना होगा :
user = User.new user.name = "John" user
समस्या यह है कि हमें इस अस्थायी चर से निपटना होगा।
यहां पर tap है विधि बचाव के लिए आती है!
tap के साथ अंतिम उदाहरण यह बन जाता है:
User.new.tap { |user| user.name = "John" }
ध्यान दें कि अस्थायी चर कैसे चला गया है, जो एक अच्छी बात है 🙂
सरणी#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 }
यह रेल से आने वाली उन विधियों में से एक है, जो अब ढांचे के बाहर उपलब्ध है 🙂
कर्नेल#स्वयं (रूबी 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 . पर परिभाषित है मॉड्यूल।
सरणी#गिनती
कभी-कभी आपको बस कुछ गिनने की जरूरत होती है।
ठेठ काउंटर + लूप का उपयोग करने के बजाय आप 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 हो सकता है कि आप जो खोज रहे हैं!
उदाहरण :
array = %w(a b c) # Same as array * 3 array.cycle(3).to_a
लेकिन cycle के लिए मेरा पसंदीदा उपयोग एक "स्विच" या "टॉगल" ऑब्जेक्ट बनाना है।
switch = %w(on off).cycle switch.next
इसके बारे में अच्छी बात यह है कि आपको इसे मैन्युअल रूप से अपडेट करने के लिए स्विच के वर्तमान मूल्य की जांच करने की आवश्यकता नहीं है।
आप बस next पर कॉल कर सकते हैं और रूबी को पता होगा कि वास्तव में क्या करना है 🙂
सारांश
आपने कुछ नई उपयोगी विधियों के बारे में सीखा है:पूर्णांक#अंक, कर्नेल#टैप, Array#values_at, हैश#transform_values, कर्नेल#स्वयं, Array#count, Enumerable#cycle।
यदि आप इन महान के बारे में पहले से ही जानते थे! यदि नहीं, तो मुझे आशा है कि आप उन्हें उपयोगी पाएंगे
इस लेख का आनंद लिया? फिर इसे अपने मित्रों के साथ साझा करें ताकि वे भी इसका आनंद उठा सकें!