रूबी के बारे में मुझे जो चीजें पसंद हैं उनमें से एक इसकी विशेषताओं की गहराई है। आप एक ऑपरेटर का उपयोग कर सकते हैं, लेकिन थोड़ी खुदाई करें और आप पाएंगे कि आपने केवल इसकी क्षमताओं की सतह को खरोंचा है। विनम्र स्प्लैट ऑपरेटर (* और **) एक बेहतरीन उदाहरण है।
आपने शायद स्प्लैट का उपयोग "कैच-ऑल" आर्गुमेंट के लिए किया है। और अधिकांश लोग उनका उपयोग केवल इसी के लिए करते हैं।
def go(x, *args) puts args.inspect end go("a", "b", "c") यदि आप नए स्टाइल के कीवर्ड आर्गुमेंट सिंटैक्स का उपयोग कर रहे हैं, तो डबल स्प्लैट का उपयोग इस तरह करें:
def go(**params) puts params.inspect end go(x: 100, y: 200) यह उपयोगी है, लेकिन आप स्प्लैट का उपयोग इससे कहीं अधिक के लिए कर सकते हैं। आइए गोता लगाएँ!
एक सरणी का उपयोग एकाधिक आर्गुमेंट पास करने के लिए
न केवल आप मेथड को परिभाषित करते समय स्प्लैट का उपयोग कर सकते हैं, बल्कि आप मेथड को कॉल करते समय भी उनका उपयोग कर सकते हैं। वे आपको एक सरणी को एक फंक्शन में पास करने देते हैं जो कई आर्गुमेंट की उम्मीद कर रहा है। सरणी में पहला आइटम पहला आर्गुमेंट बन जाता है, दूसरा आइटम दूसरा आर्गुमेंट बन जाता है, और इसी तरह।
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 आइटम प्राप्त करें
यदि आप स्प्लैट ऑपरेटर को बीच में रखते हैं, तो आप सरणी के प्रत्येक छोर से मनमानी संख्या में आइटम खींच सकते हैं।
first, *, last = [1, 2, 3, 4, 5] first # => 1 last # => 5 सीमाएं
सरणी डीस्ट्रक्चरिंग में स्प्लैट ऑपरेटर का उपयोग करते समय, आपको अभी भी सरणी आइटम की स्थिति को सरणी की शुरुआत और अंत के संबंध में निर्दिष्ट करना होगा। इसलिए यह लंबी सरणी के मध्य से आइटम निकालने के लिए सबसे अच्छा उपकरण नहीं है।
साथ ही, मुझे हैश के साथ गड़बड़ करने के लिए डबल-स्प्लैट (**) ऑपरेटर का उपयोग करके कोई अच्छी ट्रिक नहीं मिली। लंगड़ा!
सरणी निर्माण
स्प्लैट ऑपरेटर न केवल सरणी को डीस्ट्रक्चर करने के लिए बल्कि उन्हें बनाने के लिए भी उपयोगी है।
निम्नलिखित उदाहरण में, हम दो सरणी को जोड़ने के लिए स्प्लैट का उपयोग करते हैं।
[*[1,2], *[3,4]] => [1, 2, 3, 4] यह [[1, 2], [3,4]].flatten के बराबर है।
अगर यही कहानी का अंत होता, तो यह बहुत उपयोगी नहीं होता। लेकिन स्प्लैट की एक और अजीब क्षमता है। यह बुद्धिमानी से ऑब्जेक्ट को सरणी में जबरदस्ती कर सकता है।
# 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()] बस इतना ही
मुझे उम्मीद है कि यह स्पष्ट है कि आपको शायद अपने मौजूदा सरणी-मैनिपुलेशन कोड को सभी स्प्लैट का उपयोग करने के लिए फिर से नहीं लिखना चाहिए। वे हमेशा सही उपकरण नहीं होते, और जब बहुत बार उपयोग किए जाते हैं तो कोड को पढ़ना कठिन बना सकते हैं।
हालांकि, कभी-कभी एक सरणी स्प्लैट ट्रिक वही होती है जिसकी आपको आवश्यकता होती है। मुझे आशा है, जब वह समय आएगा, तो आप एक को आजमाएंगे। :)
