पैरामीटर को अलग-अलग ऑब्जेक्ट या ऑब्जेक्ट्स के सरणी के रूप में स्वीकार करना

Question

मेरे पास ऐसे कार्यों का समूह है जो ऑब्जेक्ट्स की एक सरणी लेते हैं, या एक ऑब्जेक्ट जिसमें एक ऑब्जेक्ट युक्त सरणी के रूप में माना जाता है, और मैं देख रहा हूं इसे पूरा करने के लिए एक क्लीनर तरीका। असल में, मैं जानना चाहता हूँ कि कैसे मैं निम्नलिखित समारोह अधिक संक्षिप्त में unless हिस्सा बना सकता हैं:

def foo(bar_or_bars) 
    unless bar_or_bars.is_a?(Array) 
    bar_or_bars = [bar_or_bars] 
    end 
    bar_or_bars.each { |baz| ... } 
end 

किसी भी मदद की सराहना की जाएगी! धन्यवाद।

Answer 1

पहली बात तुम कर सकते हो एक पंक्ति में unless तर्क लिखने के लिए है:

bars = bar_or_bars.is_a?(Array) ? bar_or_bars : [bar_or_bars] 

जैसा कि आप देख, मैं इसे एक नया नाम यहाँ देते हैं, यह अब एक बार या बार के रूप में, यह अब है निश्चित रूप से एक संग्रह।

इस और आपकी मूल दृष्टिकोण के साथ समस्या यह है कि यद्यपि आपका फ़ंक्शन किसी भी Enumerable पर काम कर सकता है, लेकिन आप अपने उपयोगकर्ताओं को एक विशिष्ट प्रकार का तर्क देने के लिए मजबूर करेंगे, जो बतख टाइपिंग को तोड़ देता है।

def foo(bar_or_bars) 
    bars = [*bar_or_bars] 
    bars.each { |baz| ... } 
end 

मैं बिल्कुल कि पठनीय है, हालांकि फोन नहीं होगा:

एक स्वच्छ चाल आंशिक रूप से है कि इस मुद्दे को हल करने के लिए निम्न है। यह वास्तव में खराब एपीआई डिजाइन की तरह बहुत गंध करता है। शायद आप बेहतर इसी प्रकार अनेक तर्कों लेना चाहिए:

def foo(*bars) 
    bars.each { |baz| ... } 
end 

और फोन करने वाले का फैसला है कि क्या वह एक वस्तु या किसी सरणी पारित करने के लिए चाहता है:

foo("XYZ") 
ary = ["abc", "def"] 
foo(*ary) 

Answer 2

साफ समाधान मैं पाया है उपयोग कर रहा है गिरी विधि सरणी:

Array(5) #=> [5] 
Array([1, 2, 3]) #=> [1,2,3] 

तो

def foo(bar_or_bars) 
    bars = Array(bar_or_bars) 
    bars.each { |baz| ... } 

यह भी नेस्टेड सरणियों है कि तत्वों के रूप में सरणियों पर काम करेंगे (वे बाहर चपटा जा नहीं होते)

Answer 3

मैं वर्तमान में इस का उपयोग कर रहा:

bars = [bar_or_bars].flatten