मैं रूबी में इस प्रकार के लूप के लिए कैसे करूं?ruby में एक लूप के लिए सिंटेक्स
for(int i=0; i<array.length; i++) {
}
मैं रूबी में इस प्रकार के लूप के लिए कैसे करूं?ruby में एक लूप के लिए सिंटेक्स
for(int i=0; i<array.length; i++) {
}
array.each do |element|
element.do_stuff
end
या
for element in array do
element.do_stuff
end
आप सूचकांक की जरूरत है, तो आप इस का उपयोग कर सकते हैं:
array.each_with_index do |element,index|
element.do_stuff(index)
end
मैं विशेष रूप से लूप में अनुक्रमण के लिए देख रहा था, इनमें से कोई भी समाधान तुरंत यह स्पष्ट नहीं करता कि यह कैसे करें। ओप ने कोड में सरणी के साथ अपने इरादों को धोखा दिया ... – jheriko
मेरा जवाब सावधानी से पढ़ें। इंडेक्सिंग के साथ एक लूपिंग समाधान है। – Eimantas
क्या यह हमेशा वहां था? यह बाहर निकलता है और नाक में मुझे काटता है ... – jheriko
['foo', 'bar', 'baz'].each_with_index {|j, i| puts "#{i} #{j}"}
array.each_index do |i|
...
end
यह बहुत Rubyish नहीं है, लेकिन यह सबसे अच्छा है जिस तरह से पाश के लिए सवाल से रूबी
यह शानदार है। यह सच है कि उत्तर 'प्रत्येक' नहीं बल्कि 'प्रत्येक_इंडेक्स' है। +1 –
limit = array.length;
for counter in 0..limit
--- make some actions ---
end
में ऐसा करने के लिए अन्य तरीके से पीछा कर रहा है
3.times do |n|
puts n;
end
thats करने के लिए 0, 1, 2 प्रिंट होंगे, इसलिए की तरह इस्तेमाल किया जा सकता है सरणी इटरेटर भी
कि संस्करण बेहतर लेखक की जरूरतों
क्या करने के लिए फिट लगता है? 2010 और कोई नहीं से उल्लेख किया रूबी (इसे इस्तेमाल करता है यह सिर्फ कोई भी नहीं है) के लिए/पाश में एक ठीक है:
ar = [1,2,3,4,5,6]
for item in ar
puts item
end
* .each ... do * का एक लाभ यह है कि ब्लॉक अस्थायी रूप से लूप के अंत में गुंजाइश से बाहर हो जाता है, जबकि * में * में अस्थायी रूप से छोड़ देता है। –
आप अपने सरणी तक पहुँचने के लिए, (पाश के लिए बस एक साधारण) की जरूरत नहीं है आप कर सकते हैं upto या प्रत्येक का उपयोग करें:
तक:
1.9.3p392 :030 > 2.upto(4) {|i| puts i}
2
3
4
=> 2
प्रत्येक:
1.9.3p392 :031 > (2..4).each {|i| puts i}
2
3
4
=> 2..4
मैं इसे "लूप फॉर लूप" के लिए शीर्ष लिंक के रूप में मारता रहता हूं, इसलिए मैं लूप के लिए एक समाधान जोड़ना चाहता था जहां चरण केवल '1' नहीं था। इन मामलों के लिए, आप 'चरण' विधि का उपयोग कर सकते हैं जो न्यूमेरिक्स और डेट ऑब्जेक्ट्स पर मौजूद है। मुझे लगता है कि यह 'फॉर' लूप के लिए एक करीबी अनुमान है।
start = Date.new(2013,06,30)
stop = Date.new(2011,06,30)
# step back in time over two years, one week at a time
start.step(stop, -7).each do |d|
puts d
end
+1, धन्यवाद, मैं गिनने के लिए एक अच्छा तरीका ढूंढ रहा था .. –
एक पाश बार की एक निश्चित संख्या पुनरावृति करने के लिए, कोशिश:
n.times do
#Something to be done n times
end
यह इंडेक्स का उपयोग करने की आवश्यकता होने पर काम करता है: 3. टाइम्स डू | i | – tobixen
रूबी के गणन पाश वाक्यविन्यास अलग है:
collection.each do |item|
...
end
यह 'प्रत्येक के लिए के रूप में "एक कॉल पढ़ता 'सरणी ऑब्जेक्ट इंस्टेंस' संग्रह 'की विधि जो तर्क के रूप में' blockargument 'के साथ ब्लॉक लेती है "। रूबी में ब्लॉक सिंटैक्स एकल लाइन स्टेटमेंट के लिए 'डू ... एंड' या '{...}' है।
ब्लॉक तर्क '| आइटम |' वैकल्पिक है लेकिन अगर प्रदान किया गया है, तो पहला तर्क स्वचालित रूप से लूप किए गए समेकित आइटम का प्रतिनिधित्व करता है।
तुल्यता रूबी 1.6 के बारे में नहीं एक होगा
for i in (0...array.size)
end
या
(0...array.size).each do |i|
end
या
i = 0
while i < array.size do
array[i]
i = i + 1 # where you may freely set i to any value
end
एक किताब पढ़ना एक अच्छा विचार है @johannes, लेकिन अधिमानतः! –
[रूबी-डॉक्टर: एन्यूमेबल मॉड्यूल] (http://www.ruby-doc.org/core/classes/Enumerable.html) में कुछ उपयोगी तरीकों को देखने के लिए मत भूलना। –