Ruby Language
यात्रा

से प्रत्येक

रूबी के पास कई प्रकार के एन्यूमरेटर हैं लेकिन पहले और सबसे सरल प्रकार के एन्यूमरेटर each साथ शुरू each । हम each कार्य के लिए 1 और 10 बीच प्रत्येक संख्या के लिए या odd even प्रिंट करेंगे कि each कैसे काम करता है।

मूल रूप से तथाकथित blocks को पारित करने के दो तरीके हैं। एक block कोड का एक टुकड़ा है जिसे पारित किया जा रहा है जिसे विधि द्वारा निष्पादित किया जाएगा। each विधि एक block लेता है जिसे वह वस्तुओं के संग्रह के प्रत्येक तत्व के लिए कहता है जिस पर उसे बुलाया गया था।

एक ब्लॉक को एक विधि से पास करने के दो तरीके हैं:

विधि 1: इनलाइन

(1..10).each { |i| puts i.even? ? 'even' : 'odd' }

इसे हल करने के लिए यह एक बहुत ही संकुचित और माणिक तरीका है। चलो इस टुकड़े को टुकड़े करके तोड़ दें।

1. (1..10) 1 से 10 समावेशी तक की सीमा है। यदि हम चाहते थे कि यह 1 से 10 अनन्य हो, तो हम लिखेंगे (1...10) ।
2. .each एक एन्यूमरेटर है जो each तत्व को उस वस्तु पर गणना करता है जिस पर वह कार्य कर रहा है। इस मामले में, यह सीमा में each संख्या पर कार्य करता है।
3. { |i| puts i.even? ? 'even' : 'odd' } each कथन के लिए ब्लॉक है, जिसे स्वयं आगे तोड़ दिया जा सकता है।
   1. |i| इसका मतलब है कि श्रृंखला में प्रत्येक तत्व पहचानकर्ता द्वारा ब्लॉक के भीतर प्रतिनिधित्व किया है i ।
   2. puts हर बार यह प्रिंट बाद एक स्वचालित लाइन ब्रेक है कि रूबी में एक निर्गम तरीका है। (हम स्वचालित लाइन ब्रेक नहीं चाहते हैं तो हम print उपयोग कर सकते हैं)
   3. i.even? अगर i भी जाँच करता i हम भी i % 2 == 0 उपयोग कर सकते थे; हालांकि, यह तरीकों में निर्मित उपयोग करने के लिए बेहतर है।
   4. ? "even" : "odd" यह माणिक का टर्नरी ऑपरेटर है। जिस तरह से एक टर्नरी ऑपरेटर का निर्माण होता है वह expression ? a : b । इसके लिए कम है

   if expression
     a
   else
     b
   end
   

एक पंक्ति से अधिक लंबे कोड के लिए block को एक multiline block रूप में पारित किया जाना चाहिए।

विधि 2: बहुस्तरीय

(1..10).each do |i|
  if i.even?
    puts 'even'
  else
    puts 'odd'
  end
end

एक multiline block में do ओपनिंग ब्रैकेट को बदल देता है और inline स्टाइल से एंडिंग कोष्ठक को end करता है।

रूबी रिवर्स_चेक का भी समर्थन करती है। यह ऐरे को पीछे की ओर से घुमाएगा।

@arr = [1,2,3,4]
puts @arr.inspect # output is [1,2,3,4]

print "Reversed array elements["
@arr.reverse_each do |val|
        print " #{val} " # output is 4 3 2 1
end
print "]\n"

एक वर्ग में कार्यान्वयन

Enumerable रूबी में सबसे लोकप्रिय मॉड्यूल है। इसका उद्देश्य आपको map , select , reduce , आदि जैसे मनोरंजक तरीके प्रदान करना है, जिनमें Enumerable उपयोग करने वाले वर्ग शामिल हैं, Array , Hash , Range । इसका उपयोग करने के लिए, आपको include Enumerable को include Enumerable और each लागू each ।

class NaturalNumbers
  include Enumerable

  def initialize(upper_limit)
    @upper_limit = upper_limit
  end

  def each(&block)
    0.upto(@upper_limit).each(&block)
  end
end

n = NaturalNumbers.new(6)

n.reduce(:+)                   # => 21
n.select(&:even?)              # => [0, 2, 4, 6]
n.map { |number| number ** 2 } # => [0, 1, 4, 9, 16, 25, 36]

नक्शा

परिवर्तित वस्तु लौटाता है, लेकिन मूल वस्तु वैसी ही रहती है जैसी कि थी। उदाहरण के लिए:

arr = [1, 2, 3]
arr.map { |i| i + 1 } # => [2, 3, 4]
arr # => [1, 2, 3]

map! मूल वस्तु को बदलता है:

arr = [1, 2, 3]
arr.map! { |i| i + 1 } # => [2, 3, 4]
arr # => [2, 3, 4]

नोट: आप समान कार्य collect लिए collect का उपयोग भी कर सकते हैं।

जटिल वस्तुओं पर फेरबदल करना

Arrays

आप नेस्टेड सरणियों पर पुनरावृति कर सकते हैं:

[[1, 2], [3, 4]].each { |(a, b)| p "a: #{ a }", "b: #{ b }" }

निम्नलिखित सिंटैक्स की भी अनुमति है:

[[1, 2], [3, 4]].each { |a, b| "a: #{ a }", "b: #{ b }" }

उत्पादन करेंगे:

"a: 1"
"b: 2"
"a: 3"
"b: 4"

हैश

आप कुंजी-मूल्य जोड़े पर पुनरावृति कर सकते हैं:

{a: 1, b: 2, c: 3}.each { |pair| p "pair: #{ pair }" }

उत्पादन करेंगे:

"pair: [:a, 1]"
"pair: [:b, 2]"
"pair: [:c, 3]"

आप एक साथ कुंजियों और मूल्यों पर पुनरावृति कर सकते हैं:

{a: 1, b: 2, c: 3}.each { |(k, v)| p "k: #{ k }", "v: #{ k }" }

उत्पादन करेंगे:

"k: a"
"v: a"
"k: b"
"v: b"
"k: c"
"v: c"

इटरेटर के लिए

यह 4 से 13 (समावेशी) से पुनरावृत्त होता है।

for i in 4..13
    puts "this is #{i}.th number"
end

हम इसके लिए उपयोग करने वाले सरणियों पर पुनरावृति भी कर सकते हैं

names = ['Siva', 'Charan', 'Naresh', 'Manish']

for name in names
    puts name
end

सूचकांक के साथ परिवर्तन

कभी-कभी आप किसी एन्यूमरेटर पर पुनरावृत्ति करते हुए वर्तमान तत्व की स्थिति ( सूचकांक ) जानना चाहते हैं। इस तरह के उद्देश्य के लिए, रूबी with_index विधि प्रदान करता है। इसे सभी प्रगणकों पर लागू किया जा सकता है। मूल रूप से, एन्यूमरेशन में with_index जोड़कर, आप उस एन्यूमरेशन की गणना कर सकते हैं। सूचकांक को दूसरे तर्क के रूप में एक ब्लॉक में भेजा जाता है।

[2,3,4].map.with_index { |e, i| puts "Element of array number #{i} => #{e}" }
#Element of array number 0 => 2
#Element of array number 1 => 3
#Element of array number 2 => 4
#=> [nil, nil, nil]

with_index का एक वैकल्पिक तर्क है - पहला सूचकांक जो डिफ़ॉल्ट रूप से 0 है:

[2,3,4].map.with_index(1) { |e, i| puts "Element of array number #{i} => #{e}" }
#Element of array number 1 => 2
#Element of array number 2 => 3
#Element of array number 3 => 4
#=> [nil, nil, nil]

एक विशिष्ट विधि each_with_index । इसके और each.with_index बीच एकमात्र अंतर यह है कि आप इसके लिए एक तर्क पारित नहीं कर सकते हैं, इसलिए हर समय पहला सूचकांक 0 ।

[2,3,4].each_with_index { |e, i| puts "Element of array number #{i} => #{e}" }
#Element of array number 0 => 2
#Element of array number 1 => 3
#Element of array number 2 => 4
#=> [2, 3, 4]