क्या कोई रूबी के ब्लॉक में पाइप वर्णों के उपयोग को समझा सकता है?

Question

क्या कोई मुझे रूबी के ब्लॉक में पाइप वर्णों का उपयोग कर सकता है? मैं समझता हूं कि इसमें एक वेरिएबल नाम है जिसे डेटा को फिर से सौंपा जाएगा। लेकिन इसे क्या कहा जाता है? पाइप के अंदर एक से अधिक चर हो सकता है? मुझे इसके बारे में कुछ और पता होना चाहिए? इस पर अधिक जानकारी के लिए कोई अच्छा लिंक?

उदाहरण के लिए:

25.times { | i | puts i } 

Answer 1

ब्रेसिज़ एक गुमनाम समारोह को परिभाषित, एक ब्लॉक कहा जाता है। पाइप के बीच टोकन इस ब्लॉक के तर्क हैं। आवश्यक तर्कों की संख्या इस बात पर निर्भर करती है कि ब्लॉक का उपयोग कैसे किया जाता है। प्रत्येक बार जब ब्लॉक का मूल्यांकन किया जाता है, तो ब्लॉक की आवश्यकता वाली विधि उस ऑब्जेक्ट पर आधारित मूल्य को पास करेगी।

यह एक विधि को परिभाषित करने जैसा ही है, केवल यह उस विधि से परे संग्रहीत नहीं है जो ब्लॉक स्वीकार करता है।

उदाहरण के लिए:

def my_print(i) 
    puts i 
end 

जब निष्पादित इस रूप में भी ऐसा ही होगा:

{|i| puts i} 

फर्क सिर्फ इतना ब्लॉक मक्खी पर परिभाषित किया गया है और संग्रहीत नहीं है।

उदाहरण 2: निम्नलिखित बयानों बराबर

25.times &method(:my_print) 

25.times {|i| puts i} 

हम गुमनाम ब्लॉक उपयोग करें, क्योंकि एक ब्लॉक के रूप में पारित कार्यों के बहुमत आमतौर पर अपनी स्थिति के लिए विशिष्ट और मूल्य पुनः उपयोग के लिए परिभाषित करने नहीं हैं।

तो क्या होता है जब कोई विधि किसी ब्लॉक को स्वीकार करती है? यह विधि पर निर्भर करता है।एक ब्लॉक को स्वीकार करने वाले तरीके इसे कॉलिंग ऑब्जेक्ट से मूल्यों को अच्छी तरह से परिभाषित तरीके से पास करके कॉल करेंगे। वापस लौटाया गया ब्लॉक पर आवश्यक विधि पर निर्भर करता है।

उदाहरण के लिए: 25.times {|i| puts i} में। टाइम्स 0 के बीच प्रत्येक मान के लिए एक बार ब्लॉक को कॉल करता है और इसके कॉलर के मूल्य को ब्लॉक में मान को अस्थायी चर के रूप में पास करता है I। टाइम्स कॉलिंग ऑब्जेक्ट का मान देता है। इस मामले में 25.

चलो विधि को देखें जो दो तर्कों के साथ एक ब्लॉक स्वीकार करता है।

{:key1 => "value1", :key2 => "value2"}.each {|key,value| 
    puts "This key is: #{key}. Its value is #{value}" 
} 

इस मामले में प्रत्येक प्रत्येक मुख्य/मान जोड़े पहला तर्क के रूप में कुंजी और दूसरा तर्क के रूप में मूल्य पारित करने के लिए ब्लॉक वाले कहते हैं।

Answer 2

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

उदाहरण के लिए, प्रत्येक_with_index दो चर का उपयोग करता है और तत्व को उनमें से एक में और सूचकांक को दूसरे में रखता है।

here is a good description of how blocks and iterators work

Answer 3

ब्लॉक तर्क विधि पैरामीटर (कम से कम 1.9 के रूप में) के रूप में सभी एक ही परंपराओं का पालन: आप वैकल्पिक तर्क, चर लंबाई आर्ग सूचियों, चूक, आदि को परिभाषित कर सकते यहाँ एक pretty decent summary है।

कुछ चीजों के बारे में पता होना चाहिए: क्योंकि ब्लॉक को उस क्षेत्र में वेरिएबल्स दिखाई देते हैं जिन्हें वे परिभाषित कर चुके थे, यदि आप मौजूदा चर के समान नाम के साथ तर्क में गुजरते हैं, तो यह "छाया" करेगा - आपका ब्लॉक देखेंगे मूल्य में पारित किया गया और मूल चर अपरिवर्तित होगा।

i = 10 
25.times { | i | puts i } 
puts i #=> prints '10' 

अंत में '10' प्रिंट करेगा। क्योंकि कभी-कभी यह वांछनीय व्यवहार होता है भले ही आप किसी मूल्य में गुजर रहे हों (यानी आप यह सुनिश्चित करना चाहते हैं कि आप आकस्मिक रूप से आसपास के दायरे से एक चर को घुमाएंगे) तो आप तर्क सूची के बाद अर्धविराम के बाद ब्लॉक-स्थानीय चर नाम निर्दिष्ट कर सकते हैं:

x = 'foo' 
25.times { | i ; x | puts i; x = 'bar' } 
puts x #=> prints 'foo' 

यहाँ, 'एक्स' ब्लॉक करने के लिए स्थानीय भले ही कोई मूल्य में पारित हो जाता है।