रूबी के ऐरे क्लास का उपयोग कैसे करें (उदाहरण + उपयोगी तरीके)

एक सरणी क्या है?

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

यह मददगार है, क्योंकि यदि सरणियाँ मौजूद नहीं होतीं तो आपको कई चरों का उपयोग करना पड़ता।

उदाहरण :

a =1b =2c =3

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

नंबर =[1, 2, 3]

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

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

पसंद करें :

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

आइए सरणियों के बारे में अधिक जानें ताकि आप उनका सर्वोत्तम उपयोग कर सकें!

सामग्री

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

सरणी शून्य-अनुक्रमित हैं

आप तत्वों तक पहुंच . कर सकते हैं एक सरणी के अंदर उनके अनुक्रमणिका . का उपयोग करके , जो 0 से शुरू होता है।

यदि आपके पास "बिल्ली", "कुत्ता" और "बाघ" शब्दों के साथ एक सरणी है, तो यह इसे पसंद करेगा:

यहां एक कोड उदाहरण दिया गया है जो चित्र में डेटा का प्रतिनिधित्व करता है:

["बिल्ली", "कुत्ता", "बाघ"]

अब :

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

रूबी ऐरे के तरीके

आइए सीखते हैं कि आप एक सरणी कैसे बना सकते हैं।

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

खाली सरणी प्रारंभ करें :

उपयोगकर्ता =[]

डेटा के साथ एक सरणी प्रारंभ करें :

उपयोगकर्ता =["जॉन", "डेविड", "पीटर"]

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

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

उदाहरण :

उपयोगकर्ता =%w(जॉन डेविड पीटर)

अब जब हमारे पास एक सरणी है तो आप इसमें शामिल तत्वों तक पहुंच सकते हैं।

यहां बताया गया है :

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

आप पहली और आखिरी विधियों का भी उपयोग कर सकते हैं:

users.first # array का पहला तत्वusers.last # सरणी का अंतिम तत्व

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

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

 यहां बताया गया है कि आप अपने सरणी से तत्वों को कैसे हटाते हैं:
 
last_user =users.pop # सरणी से अंतिम तत्व को हटाता है और ituser.delete_at(0) को लौटाता है # सरणी के पहले तत्व को हटाता है
 

 शिफ्ट और अनशिफ्ट तरीके भी हैं, जो पॉप/पुश के समान हैं लेकिन ऐरे के सामने तत्व लेते हैं या जोड़ते हैं।
 
users.unshift "robert" # arrayusers.shift के सामने एक एलिमेंट जोड़ता है # एरे के पहले एलिमेंट को हटाता है और उसे वापस करता है
 

 क्या इस सरणी में एक निश्चित वस्तु शामिल है या शामिल है?
 

 जांचें कि रूबी में किसी सरणी में कोई मान मौजूद है या नहीं: 
 
नंबर =[1,2,3]नंबर शामिल हैं?(2)# truenumbers.include?(10)# false
 

 सरणी की लंबाई क्या है? (दूसरे शब्दों में, इसमें कितने तत्व हैं)
 
words =["cat", "coconut", "bacon"]words.size# 3
 

 यहां आपके लिए एक छोटी सी चीटशीट है :
 
ऑपरेशन
 
तरीके
 
 
 
आरंभ करें
 
Array.new, [], %w
 
 
पढ़ें
 
[0], प्रथम, अंतिम
 
 
जोड़ें
 
पुश, <<, अनशिफ्ट
 
 
निकालें
 
पॉप, डिलीट_एट, शिफ्ट
 
 
 
 
किसी सरणी को स्ट्रिंग में कैसे बदलें
 

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

 यहां एक उदाहरण दिया गया है :
 
अक्षर =%w(a b c d)letters.join# "abcd"
 

 ध्यान दें कि यह विधि 1 वैकल्पिक पैरामीटर लेती है ताकि आप सरणी तत्वों के बीच एक विभाजक को परिभाषित कर सकें जब वे एक साथ जुड़ जाते हैं।
 
अक्षर =%w(a b c d)letters.join(" ")# "a b c d"
 

 यदि आप स्ट्रिंग से सरणी तक रिवर्स ऑपरेशन चाहते हैं, तो आप split . का उपयोग करना चाहते हैं विधि:
 
"a b c"split
 

 जिसके परिणामस्वरूप:
 
["a", "b", "c"]
 
बहु-आयामी सरणियाँ (2D Arrays और अधिक)
 

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

 2d सरणी का उदाहरण :
 
उपयोगकर्ता =[ [1, 'पीटर'], [2, 'स्टीवन']]
 

 पहले उप-सरणी से पहले तत्व तक पहुँचने के लिए आप इस सिंटैक्स का उपयोग कर सकते हैं:
 
उपयोगकर्ता[0][0]# 1
 

 और पहले उप-सरणी के दूसरे तत्व के लिए:
 
उपयोगकर्ता[0][1]# 'पीटर'
 

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

 आप फ़्लैटन विधि का उपयोग करके ऐसा कर सकते हैं:
 
users.flatten# [1, "पीटर", 2, "स्टीवन"]
 
रूबी सरणियों पर पुनरावृति कैसे करें
 

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

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

 उदाहरण :प्रत्येक का उपयोग करके अपनी सरणी प्रिंट करें
 
users.each { |item| आइटम डालता है }
 

 यदि आपको मूल्य और सूचकांक दोनों के साथ काम करने की आवश्यकता है तो आप सरणी के प्रत्येक को अनुक्रमणिका विधि के साथ उपयोग कर सकते हैं:
 
users.each_with_index { |item, idx| "#{item} को इंडेक्स #{idx}" }
 . के साथ रखता है <ब्लॉकक्वॉट> 

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

 उदाहरण :मानचित्र का उपयोग करके अपने ऐरे में प्रत्येक शब्द को बड़े अक्षरों में लिखें।
 
उपयोगकर्ता =उपयोगकर्ता.मैप { |उपयोगकर्ता| user.capitalize }users =users.map(&:capitalize)
 

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

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

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

 उदाहरण :10 से बड़ी सभी संख्याएं खोजें:
 
नंबर्स =[3, 7, 12, 2, 49]नंबर चुनें। {|n| n> 10 }# => 12, 49
 
नकारात्मक अनुक्रमण
 

 आपने सीखा है कि यदि आप रूबी सरणी से किसी निश्चित तत्व तक पहुंचना चाहते हैं तो आपको अनुक्रमण (या first जैसी विधियों का उपयोग करने की आवश्यकता है। &last )।
 

 लेकिन नकारात्मक अनुक्रमण के बारे में क्या?
 

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

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

 उदाहरण :
 
अक्षर =["ए", "बी", "सी"]अक्षर[-1]# "सी"अक्षर[-2]# "बी"
 
अधिक सरणी संचालन
 

 आप सरणियों का उपयोग करके बहुत सी चीजें कर सकते हैं, जैसे उन्हें क्रमबद्ध करना या यादृच्छिक तत्वों को चुनना।
 

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

 आप एक सरणी से डुप्लिकेट तत्वों को भी हटा सकते हैं, यदि आप खुद को अक्सर ऐसा करते हुए पाते हैं, तो आप इसके बजाय एक सेट का उपयोग करने पर विचार कर सकते हैं।
 
नंबर्स =[1, 3, 3, 5, 5]नंबर्स =नंबर्स.uniq# => [1, 3, 5]
 

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

 यदि आप अपनी सरणी से एक यादृच्छिक तत्व चुनना चाहते हैं तो आप sample . का उपयोग कर सकते हैं विधि:
 
नंबर.नमूना
 

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

 उदाहरण :सरणी से पहले 3 तत्वों को बदले बिना लें:
 
numbers.take(3)numbers[0,3]
 

 आप अधिक उन्नत रूबी सरणी स्लाइसिंग कर सकते हैं। उदाहरण के लिए, आप सभी तत्वों को प्राप्त करना चाह सकते हैं लेकिन पहले वाले:
 
नंबर[1..-1]
 

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

 एक सरणी का आकार प्राप्त करें:
 
numbers.size# 5
 

 जांचें कि कोई सरणी खाली है या नहीं:
 
numbers.खाली?# गलत
 

 nil निकालें मान:
 
नंबर < 
एकाधिक सरणियों के साथ संचालन
 

 यदि आपके पास दो सरणियाँ हैं और आप उनमें शामिल होना या उन्हें एक में मिलाना चाहते हैं तो आप इसे इस तरह कर सकते हैं:
 
# तेज़, क्योंकि यह उपयोगकर्ताओं को बदलता है arrayusers.concat(new_users) # धीमा, क्योंकि यह एक नया arrayusers बनाता है +=new_users 
 

 आप इस तरह से एक सरणी से तत्वों को भी हटा सकते हैं, जहां users_to_delete एक सरणी भी है:
 
उपयोगकर्ता =उपयोगकर्ता - user_to_delete
 

 अंत में, आप एक ही समय में दो सरणियों में दिखाई देने वाले तत्व प्राप्त कर सकते हैं:
 
उपयोगकर्ता और new_users
 
निष्कर्ष
 

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

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

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

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