रूबी में अलग-अलग सरणियों को बनाने और फाड़ने के लिए स्प्लैट्स का उपयोग करना

रूबी के बारे में मुझे जो चीजें पसंद हैं उनमें से एक इसकी विशेषताओं की गहराई है। आप एक ऑपरेटर का उपयोग कर सकते हैं, लेकिन थोड़ी खुदाई करें और आप पाएंगे कि आप केवल उस सतह को खरोंच रहे हैं जो वह करने में सक्षम है। विनम्र स्प्लैट ऑपरेटर (* और ** ) एक महान उदाहरण है।

आपने शायद "कैच-ऑल" तर्कों के लिए स्पैट्स का उपयोग किया है। और यही वह सब है जिसके लिए अधिकांश लोग उनका उपयोग करते हैं।

def go(x, *args)
  puts args.inspect
end

go("a", "b", "c")

यदि आप न्यूफ़ंगल कीवर्ड तर्क सिंटैक्स का उपयोग कर रहे हैं, तो इस तरह से डबल स्प्लैट का उपयोग करें:

def go(**params)
  puts params.inspect
end

go(x: 100, y: 200)

यह उपयोगी है, लेकिन आप बहुत अधिक के लिए splats का उपयोग कर सकते हैं। चलो गोता लगाएँ!

एकाधिक तर्क पारित करने के लिए एक सरणी का उपयोग करना

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

def go(x, y)
end

point = [12, 10]
go(*point)

और यह न भूलें कि आप नई शैली के कीवर्ड तर्कों के लिए डबल स्प्लैट का उपयोग कर सकते हैं:

def go(x:, y:)
end

point = { x: 100, y: 200 }
go(**point)

स्प्लैट को अंत में नहीं जाना है

हालांकि तर्क सूची के अंत में अपने अलग-अलग तर्क रखना आम बात है, लेकिन इसके लिए किसी कानून की आवश्यकता नहीं है।

आप तर्क सूची में कहीं भी छींटा डाल सकते हैं।

def go(x, *args, y)
  puts x # => 1
  puts y # => 5
  puts args.inspect # => [2,3,4]
end

go(1, 2, 3, 4, 5)

सरणी विनाश

तर्कों के साथ ये सभी तरकीबें सरणी को नष्ट करने का एक विशेष मामला है।

यदि आप "सरणी विनाशकारी" शब्द से परिचित नहीं हैं, तो इसका सीधा सा मतलब है कि एक सरणी को अलग-अलग वस्तुओं में तोड़ना। यह इस तरह दिखता है:

a, b = [1, 2]
puts a
# 1
puts b
# 2

यह अच्छी तरह से काम करता है लेकिन सरणी में प्रत्येक आइटम को पकड़ने के लिए एक चर निर्दिष्ट करना दर्द हो सकता है। स्प्लैट ऑपरेटर इसके आसपास हो जाता है - अनिवार्य रूप से वाइल्डकार्ड की तरह काम करता है। आइए कुछ उदाहरण देखें।

किसी सरणी से पहला आइटम पॉपिंग करना

कभी-कभी मूल सरणी को बदले बिना किसी सरणी के पहले आइटम को पॉप करने में सक्षम होना उपयोगी होता है। यह उदाहरण यही करता है।

first, *remainder = [1, 2, 3, 4, 5]
first
# => 1
remainder
# => [2, 3, 4, 5]

यदि आप केवल पहला आइटम चाहते हैं लेकिन बाकी सरणी नहीं चाहते हैं, तो आप सिंटैक्स का उपयोग कर सकते हैं:

first, * = [1, 2, 3, 4, 5]
first
# => 1

आखिरी आइटम को पॉप अप करना

आइटम को शुरुआत के बजाय ऐरे के अंत से हटाने के लिए, बस शुरुआत में इस तरह से स्प्लैट चिपका दें:

*prefix, last = [1, 2, 3, 4, 5]
last
# => 5
prefix
# => [1, 2, 3, 4]

फिर से, यदि हम एक विशिष्ट चर नहीं चाहते हैं, तो हमें इसे निर्दिष्ट करने की आवश्यकता नहीं है:

सरणी के पहले और अंतिम n आइटम प्राप्त करें

यदि आप splat ऑपरेटर को बीच में रखते हैं, तो आप ऐरे के प्रत्येक छोर से एक मनमाना संख्या में आइटम खींच सकते हैं।

first, *, last =  [1, 2, 3, 4, 5]
first
# => 1
last
# => 5

सीमाएं

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

साथ ही, मुझे डबल-स्प्लैट (** .) का उपयोग करके कोई अच्छी चाल नहीं मिल रही है ) ऑपरेटर हैश के साथ गड़बड़ करने के लिए। लंगड़ा!

सरणी बनाना

स्प्लैट ऑपरेटर न केवल विनाशकारी सरणियों के लिए बल्कि उनके निर्माण के लिए भी उपयोगी है।

निम्नलिखित उदाहरण में, हम दो सरणियों को जोड़ने के लिए splat का उपयोग करते हैं।

[*[1,2], *[3,4]]
=> [1, 2, 3, 4]

यह [[1, 2], [3,4]].flatten . के बराबर है .

अगर यह कहानी का अंत होता, तो यह बहुत उपयोगी नहीं होता। लेकिन splat में एक और अजीबोगरीब क्षमता है। यह समझदारी से वस्तुओं को सरणियों में ज़बरदस्ती कर सकता है।

# Usually `*thing` wraps `thing` in an array
x = *"hi mom"
# => ["hi mom"]

# ...unless it's nil
x = *nil
# => []

# Arrays are passed through unchanged
x = *[1,2,3]
# => [1, 2, 3]

# But hashes are converted to arrays
x = *{a: 1}
# => [[:a, 1]]

यह हमें एक टन मैनुअल प्रकार के ज़बरदस्ती किए बिना सरणियों के निर्माण के लिए एक उपकरण देता है।

उदाहरण के लिए, कल्पना करें कि आप कुछ कॉन्फ़िगरेशन सिस्टम के लिए स्ट्रिंग्स की एक सरणी एकत्र कर रहे हैं। आम तौर पर आप यह करना चाहेंगे:

• जांचें कि क्या ऐरे मौजूद है, और अगर नहीं तो इसे इनिशियलाइज़ करें
• अगर कोई स्ट्रिंग्स की एक सरणी जोड़ने की कोशिश करता है, न कि केवल एक स्ट्रिंग, तो समझदारी से जवाब दें

स्प्लैट ऑपरेटर हमें यह मुफ़्त देता है:

# Your configuration hash may or may not have
# an existing :ignore array. 
config = { }

# The callback function might return an array
# or it might return a single item. 

def add_ignores
  "scoundrels" # could also be an array like ["scoundrels", "cads", "ne'er-do-wells"]
end

# This is where the magic happens. No matter what you 
# start with you get an array of things to ignore. 
config[:ignore] = [*config[:ignore], *add_ignores()]

बस इतना ही

मुझे आशा है कि यह स्पष्ट है कि आपको शायद splats का उपयोग करने के लिए अपने सभी मौजूदा सरणी-हेरफेर कोड को फिर से लिखना नहीं चाहिए। वे हमेशा सही उपकरण नहीं होते हैं, और जब वे अक्सर उपयोग किए जाते हैं तो वे कोड को पढ़ने में कठिन बना सकते हैं।

हालाँकि, कभी-कभी एक ऐरे स्प्लैट ट्रिक ठीक वही होती है जिसकी आपको आवश्यकता होती है। मुझे उम्मीद है, जब वह समय आएगा, तो आप इसे आजमाएंगे। :)