से अधिक जाएं Enumerable # में यात्रा

Question

(1..4).collect do |x| 
    next if x == 3 
    x + 1 
end # => [2, 3, nil, 5] 
    # desired => [2, 3, 5] 

तो next के लिए स्थिति उत्पन्न होने पर एकत्रित करते हैं, collect सरणी में nil डालता है, जबकि मैं क्या करने की कोशिश कर रहा हूँ लौटे सरणी में कोई तत्व डाल दिया जाता है, तो शर्त है मिला। क्या यह लौटा सरणी पर delete_if { |x| x == nil } पर कॉल किए बिना संभव है?

(रूबी 1.8.7 का उपयोग करना; मेरी कोड अंश भारी पृथक है)

Answer 1

विधि Enumerable#reject जो सिर्फ उद्देश्य में कार्य करता है:

(1..4).reject{|x| x == 3}.collect{|x| x + 1} 

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

बीटीडब्ल्यू, map (या collect) आउटपुट के लिए गणना के इनपुट के प्रत्यक्ष मैपिंग के लिए उपयोग किया जाता है। यदि आपको विभिन्न तत्वों को आउटपुट करने की आवश्यकता है, तो संभावना है कि आपको Enumerable की दूसरी विधि की आवश्यकता है।

संपादित करें: आप तथ्य यह है कि तत्वों में से कुछ दो बार दोहराया जाता है से परेशान हैं, तो आप कम सुरुचिपूर्ण समाधान के आधार पर उपयोग कर सकते हैं inject (या उसके समान विधि each_with_object नाम):

(1..4).each_with_object([]){|x,a| a << x + 1 unless x == 3} 

Answer 2

मैं बस उसके एवज में सरणी है, जो एक सरणी में नहीं के बराबर से किसी उदाहरण को हटा पर .compact कहेंगे। आप इसे चाहते हैं, तो मौजूदा सरणी (बिना किसी कारण के लिए नहीं) को संशोधित करने, .compact! का उपयोग करें:

(1..4).collect do |x| 
    next if x == 3 
    x 
end.compact! 

Answer 3

मैं उपयोग करने के लिए सुझाव है:

(1..4).to_a.delete_if {|x| x == 3} 

कलेक्ट + अगले स्टेटमेंट के बजाय

।

Answer 4

सिर्फ एक सुझाव है, तुम क्यों यह इस तरह से नहीं करते हैं: क्या आप सरणी से तत्व नहीं के बराबर दूर करने के लिए एक और यात्रा को बचाया है कि रास्ते में

result = [] 
(1..4).each do |x| 
    next if x == 3 
    result << x 
end 
result # => [1, 2, 4] 

। आशा है कि यह मदद करता है =)

Answer 5

आप खींच सकता है एक सहायक विधि में निर्णय लेने की, और इसका इस्तेमाल Enumerable#reduce के माध्यम से:

def potentially_keep(list, i) 
    if i === 3 
    list 
    else 
    list.push i 
    end 
end 
# => :potentially_keep 

(1..4).reduce([]) { |memo, i| potentially_keep(memo, i) } 
# => [1, 2, 4]