रूबी एरे में महारत: व्यावहारिक उदाहरण और आवश्यक मेथड्स

एरे क्या है?

एक एरे रूबी में एक बिल्ट-इन क्लास है, जो शून्य या अधिक आइटम्स की सूची रखती है, और इसमें ऐसे मेथड्स शामिल हैं जो आपको इन सभी आइटम्स को आसानी से जोड़ने, एक्सेस करने और लूप करने में मदद करते हैं।

यह उपयोगी है, क्योंकि यदि एरे मौजूद नहीं होते तो आपको कई वेरिएबल्स का उपयोग करना पड़ता।

उदाहरण:

 a = 1
b = 2
c = 3 

लेकिन इसके बजाय, आप कर सकते हैं:

 numbers = [1, 2, 3] 

सबसे अच्छा हिस्सा?

आप एरे के अंदर कुछ भी रख सकते हैं!

जैसे:

• संख्याएं
• स्ट्रिंग्स
• और एरे! (जो इसे बहु-आयामी एरे बना देगा)

आइए एरे के बारे में और सीखें ताकि आप उनका सर्वोत्तम उपयोग कर सकें!

विषयसूची

• 1 एरे ज़ीरो-इंडेक्स्ड हैं
• 2 रूबी एरे मेथड्स
• 3 एरे को स्ट्रिंग में कैसे बदलें
• 4 बहु-आयामी एरे (2D एरे और अधिक)
• 5 रूबी एरे पर कैसे पुनरावृति करें
• 6 नेगेटिव इंडेक्सिंग
• 7 अधिक एरे ऑपरेशन्स
• 8 एकाधिक एरे के साथ ऑपरेशन्स
• 9 निष्कर्ष
  • 9.1 संबंधित

एरे ज़ीरो-इंडेक्स्ड हैं

आप एरे के अंदर एलिमेंट्स को उनके इंडेक्स का उपयोग करके एक्सेस कर सकते हैं, जो 0 से शुरू होता है।

यदि आपके पास "cat", "dog" और "tiger" शब्दों वाली एक सरणी होती तो यह ऐसा दिखता:

यहां एक कोड उदाहरण है जो चित्र में डेटा को दर्शाता है:

 ["cat", "dog", "tiger"] 

अब:

आप खोजेंगे कि आप एरे के साथ क्या कर सकते हैं!

रूबी एरे मेथड्स

आइए शुरू करते हैं कि आप एरे कैसे बना सकते हैं।

आप एक खाली सरणी बना सकते हैं, फिर इसमें नए आइटम्स जोड़ सकते हैं, या आप प्रारंभिक मानों के साथ एक सरणी बना सकते हैं।

खाली सरणी इनिशियलाइज़ करें:

 users = [] 

डेटा के साथ सरणी इनिशियलाइज़ करें:

 users = ["john", "david", "peter"] 

यदि आप स्ट्रिंग-ओनली सरणी बना रहे हैं…

आप %w के साथ सरणी बनाकर हर स्ट्रिंग के लिए उद्धरण टाइप करने से बच सकते हैं।

उदाहरण:

 users = %w(john david peter) 

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

यहाँ कैसे:

 users[0] # सरणी का पहला एलिमेंट
users[1] # सरणी का दूसरा एलिमेंट
users[2] # सरणी का तीसरा एलिमेंट 

आप first और last मेथड्स का भी उपयोग कर सकते हैं:

 users.first # सरणी का पहला एलिमेंट
users.last # सरणी का अंतिम एलिमेंट 

आपके सरणी में आइटम्स जोड़ने का तरीका यहां दिया गया है:

 # इन दोनों का प्रभाव समान है, << पसंद किया जाता है।
users.push "andrew"
users << "andrew" 

आपके सरणी से एलिमेंट्स हटाने का तरीका यहां दिया गया है:

 last_user = users.pop # सरणी से अंतिम एलिमेंट हटाता है और इसे लौटाता है
user.delete_at(0) # सरणी का पहला एलिमेंट हटाता है 

Shift और unshift मेथड्स भी हैं, जो pop/push के समान हैं लेकिन सरणी के सामने एलिमेंट्स लेते या जोड़ते हैं।

 users.unshift "robert" # सरणी के सामने एक एलिमेंट जोड़ता है
users.shift # सरणी का पहला एलिमेंट हटाता है और इसे लौटाता है 

क्या इस सरणी में कोई निश्चित आइटम शामिल है?

रूबी में जांचें कि कोई मान सरणी में मौजूद है या नहीं:

 numbers = [1,2,3]
numbers.include?(2) # true
numbers.include?(10) # false 

सरणी की लंबाई क्या है? (दूसरे शब्दों में, इसमें कितने एलिमेंट्स हैं)

 words = ["cat", "coconut", "bacon"]
words.size # 3

यहां आपके लिए एक छोटी चीटशीट है:

एरे को स्ट्रिंग में कैसे बदलें

आप Array#join मेथड का उपयोग करके किसी भी सरणी को स्ट्रिंग में बदल सकते हैं।

यहां एक उदाहरण है:

 letters = %w(a b c d)
letters.join # "abcd" 

ध्यान दें कि यह मेथड 1 वैकल्पिक पैरामीटर लेता है ताकि आप सरणी एलिमेंट्स के बीच एक सेपरेटर परिभाषित कर सकें जब वे एक साथ जुड़ते हैं।

 letters = %w(a b c d)
letters.join(" ") # "a b c d" 

यदि आप रिवर्स ऑपरेशन चाहते हैं, स्ट्रिंग से सरणी, तो आप split मेथड का उपयोग करना चाहेंगे:

 "a b c".split 

जिसका परिणाम है:

 ["a", "b", "c"] 

बहु-आयामी एरे (2D एरे और अधिक)

एक सरणी अन्य सरणियों से बनी हो सकती है, हम इसे बहु-आयामी सरणी कहते हैं।

2d सरणी का उदाहरण:

 users = [
  [1, 'Peter'],
  [2, 'Steven']
] 

पहली उप-सरणी से पहले एलिमेंट को एक्सेस करने के लिए आप इस सिंटैक्स का उपयोग कर सकते हैं:

 users[0][0] # 1 

और पहली उप-सरणी के दूसरे एलिमेंट के लिए:

 users[0][1] # 'Peter' 

कुछ मामले हैं जहां आप बहु-आयामी सरणी को नियमित सरणी में बदलना चाहते हैं।

आप flatten मेथड का उपयोग करके ऐसा कर सकते हैं:

 users.flatten # [1, "Peter", 2, "Steven"] 

रूबी एरे पर कैसे पुनरावृति करें

अब जब आपके पास एक सरणी है तो क्या यह अच्छा नहीं होगा यदि आप इसकी सामग्री को गिन सकें और प्रिंट कर सकें?

अच्छी खबर यह है कि आप कर सकते हैं!

उदाहरण: each का उपयोग करके अपनी सरणी प्रिंट करें

 users.each { |item| puts item } 

यदि आपको मान और इंडेक्स दोनों के साथ काम करने की आवश्यकता है तो आप सरणी के each_with_index मेथड का उपयोग कर सकते हैं:

 users.each_with_index { |item, idx| puts "#{item} with index #{idx}" } 

नोट: इनमें से अधिकांश लूपिंग ऑपरेशन्स Enumerable मॉड्यूल की बदौलत उपलब्ध हैं, जो डिफ़ॉल्ट रूप से Array क्लास में मिक्स्ड है।

उदाहरण: map का उपयोग करके अपनी सरणी में हर शब्द को कैपिटलाइज़ करें।

 users = users.map { |user| user.capitalize }
users = users.map(&:capitalize) 

map मेथड सरणी को इन-प्लेस संशोधित नहीं करता, यह संशोधित एलिमेंट्स के साथ एक नई सरणी लौटाता है, इसलिए हमें परिणामों को वापस वेरिएबल में असाइन करने की आवश्यकता है।

एक map! (विस्मयादिबोधक बिंदु पर ध्यान दें) मेथड भी है जो सरणी को सीधे संशोधित करेगा, लेकिन सामान्यतः सरल संस्करण पसंद किया जाता है।

एक और चीज जो आप करना चाह सकते हैं वह है अपनी सरणी में उन सभी आइटम्स को ढूंढना जो कुछ मानदंडों को पूरा करते हैं।

उदाहरण: 10 से बड़ी सभी संख्याएँ ढूंढें:

 numbers = [3, 7, 12, 2, 49]
numbers.select { |n| n > 10 } # => 12, 49 

नेगेटिव इंडेक्सिंग

आपने सीखा कि यदि आप रूबी सरणी से किसी निश्चित एलिमेंट को एक्सेस करना चाहते हैं तो आपको इंडेक्सिंग (या first और last जैसे मेथड्स) का उपयोग करने की आवश्यकता है।

लेकिन नेगेटिव इंडेक्सिंग के बारे में क्या?

मैं -1 जैसी किसी चीज का उपयोग करने की बात कर रहा हूँ जैसे आपकी सरणी इंडेक्स।

रूबी क्या करेगा वह सरणी के अंत से शुरू होगा। तो -1 आपको अंतिम आइटम देगा, -2 आपको अंतिम से दूसरा देगा, आदि।

उदाहरण:

 letters = ["a", "b", "c"]
letters[-1] # "c"
letters[-2] # "b" 

अधिक एरे ऑपरेशन्स

ऐसी बहुत सी चीजें हैं जो आप सरणियों का उपयोग करके कर सकते हैं, जैसे उन्हें सॉर्ट करना या रैंडम एलिमेंट्स चुनना।

आप सरणी को सॉर्ट करने के लिए sort मेथड का उपयोग कर सकते हैं, यह ठीक काम करेगा यदि आपकी सरणी में केवल स्ट्रिंग्स या नंबर हैं। अधिक उन्नत सॉर्टिंग के लिए sort_by देखें।

 numbers = numbers.sort 

आप सरणी से डुप्लिकेट एलिमेंट्स भी हटा सकते हैं, यदि आप खुद को अक्सर ऐसा करते हुए पाते हैं तो आप Set का उपयोग करने पर विचार कर सकते हैं।

 numbers = [1, 3, 3, 5, 5]
numbers = numbers.uniq # => [1, 3, 5] 

ध्यान दें कि यह आपकी सरणी को स्थायी रूप से नहीं बदलता। अधिकांश रूबी मेथड्स आपके द्वारा अनुरोधित परिवर्तनों के साथ एक नई सरणी बनाएंगे। इसलिए यदि आप परिणामों को सहेजना चाहते हैं तो आपको एक वेरिएबल का उपयोग करना होगा या इस उदाहरण में, uniq! मेथड का उपयोग करें।

यदि आप अपनी सरणी से एक रैंडम एलिमेंट चुनना चाहते हैं तो आप sample मेथड का उपयोग कर सकते हैं:

 numbers.sample 

आप अपनी सरणी को "स्लाइस" भी करना चाह सकते हैं, पूरी चीज के बजाय इसका एक हिस्सा लेना।

उदाहरण: सरणी से पहले 3 एलिमेंट्स लें, बिना इसे बदले:

 numbers.take(3)
numbers[0,3] 

आप अधिक उन्नत रूबी सरणी स्लाइसिंग कर सकते हैं। उदाहरण के लिए, आप पहले को छोड़कर सभी एलिमेंट्स प्राप्त करना चाह सकते हैं:

 numbers[1..-1] 

कॉमा (0,3) और रेंज (1..-1) का उपयोग करने के बीच अंतर पर ध्यान दें। पहला कहता है "मुझे इंडेक्स 0 से शुरू होने वाले 3 एलिमेंट्स दो", जबकि अंतिम कहता है "मुझे इस रेंज में वर्ण दो"।

सरणी का आकार प्राप्त करें:

 numbers.size # 5 

जांचें कि सरणी खाली है या नहीं:

 numbers.empty? # false 

nil मान हटाएं:

 numbers << nil # [1, 3, 3, 5, 5, nil]
numbers.compact # [1, 3, 3, 5, 5] 

एकाधिक एरे के साथ ऑपरेशन्स

यदि आपके पास दो सरणियाँ हैं और आप उन्हें जोड़ना या मर्ज करना चाहते हैं तो आप इसे इस तरह कर सकते हैं:

 # तेज़, क्योंकि यह users सरणी को बदलता है
users.concat(new_users)
# धीमा, क्योंकि यह एक नई सरणी बनाता है
users += new_users 

आप एक सरणी से एलिमेंट्स को इस तरह भी हटा सकते हैं, जहां users_to_delete भी एक सरणी है:

 users = users - users_to_delete 

अंत में, आप उन एलिमेंट्स को प्राप्त कर सकते हैं जो दो सरणियों में एक साथ दिखाई देते हैं:

 users & new_users 

निष्कर्ष

रूबी एरे बहुत उपयोगी हैं और वे आपके साथ एक शक्तिशाली सहयोगी होंगे।

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

अभ्यास परिपूर्ण बनाता है!

यदि आपको यह उपयोगी लगा तो कृपया इस पोस्ट को शेयर करें और नीचे मेरे न्यूज़लेटर की सदस्यता लें 🙂