रुबी प्रत्येक पुनरावर्तक निष्पादन में पहले क्यों जाता है?

Question

मैं रूबी में सरल कार्यों को करने वाली एक अजीब चीज में आया हूं। मैं तो बस प्रत्येक विधि के साथ वर्णमाला पुनरावृति करना चाहते हैं लेकिन यात्रा निष्पादन में पहली जाता है: इस में

alfawit = ("a".."z") 
puts "That's an alphabet: \n\n #{ alfawit.each { |litera| puts litera } } " 

और इस कोड के परिणाम: (संक्षिप्त)

a 
b 
c 
⋮ 
x 
y 
z 
That's an alphabet: 

a..z 

कोई भी विचार क्यों यह की तरह काम करता यह या क्या माना जाता है कि मैंने गलत किया?

अग्रिम धन्यवाद।

Answer 1

क्योंकि आपके each कॉल को आपके स्ट्रिंग अक्षर में इंटरपोलेट किया गया है जो निश्चित स्ट्रिंग से पहले निष्पादित किया गया है। इसके अलावा, each एक Enumerable देता है, वास्तव में आप इसे भी प्रिंट करते हैं। प्रयास करें कि यह एक

alfawit = ("a".."z") 
puts "That's an alphabet: \n\n" 
alfawit.each { |litera| puts litera } 

या

puts "That's an alphabet: \n\n" 
("a".."z").each { |litera| puts litera } 

यदि आप चाहते हैं, लेकिन इस तरह से

alfawit = ("a".."z") 
puts "That's an alphabet: \n\n#{alfawit.to_a.join("\n")}" 

Answer 2

आप आसानी से देख सकते हैं क्या हो रहा है अगर आप में प्रक्षेप भाग को निकालने आप प्रक्षेप उपयोग कर सकते हैं एक चर:

alfawit = ("a".."z") 
foo = alfawit.each { |litera| puts litera } 
puts "That's an alphabet: \n\n #{ foo } " 

दूसरी पंक्ति समस्या का कारण बन रही है: each सीमा के प्रत्येक तत्व के लिए ब्लॉक को आमंत्रित करता है और फिर रिसीवर देता है, ताकि fooalfawit बन जाए।

यहाँ एक और तरीका वांछित परिणाम प्राप्त करने के लिए है:

alfawit = "a".."z" 
puts "That's an alphabet:", alfawit.to_a 

puts आउटपुट एक नई लाइन पर प्रत्येक तर्क है, लेकिन सरणी तर्क के लिए, यह एक नई लाइन पर प्रत्येक तत्व आउटपुट। परिणाम:

That's an alphabet: 
a 
b 
c 
⋮ 
x 
y 
z 

इसी तरह, आप में सीमा बंद कर सकते हैं के माध्यम से एक argument list*:

alfawit = "a".."z" 
puts "That's an alphabet:", *alfawit 

कि के बराबर है:

puts "That's an alphabet:", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"