ऐरे एक आम डेटा स्ट्रक्चर है, जिसके साथ काम करना पड़ता है।
इनके साथ काम करने के लिए मेथड का एक पूरा समूह मौजूद है।
इसमें सॉर्ट करना, उलटना, बीच में जोड़ना और ऐसे ही कई और काम शामिल हैं।
इनमें से कुछ मेथड डेस्ट्रक्टिव होते हैं, यानी वे मूल ऐरे को ही बदल देते हैं।
बाकी नॉन-डेस्ट्रक्टिव होते हैं, यानी वे एक नया ऐरे लौटाते हैं और मूल ऐरे को नहीं बदलते।
ऐरे के साथ काम करते समय सबसे ज़्यादा इस्तेमाल होने वाले कुछ मेथड ये हैं:
insert
ऐरे में कोई एलिमेंट जोड़ते समय आप insert मेथड इस्तेमाल कर सकते हैं, जो आर्गुमेंट के रूप में एक इंडेक्स और एक एलिमेंट लेता है।
एलिमेंट बताए गए इंडेक्स पर जोड़ दिया जाता है, और ऐरे के बाकी एलिमेंट एक जगह दाईं ओर खिसक जाते हैं।
अगर इंडेक्स ऐरे की सीमा से बाहर हो, तो कोड IndexError उठाता है।
numbers = [1, 2, 3]
numbers.insert(1, 4)
numbers # => [1, 4, 2, 3]
numbers.insert(5, 5) # => Error: Index out of bounds (IndexError)
delete
जब आप ऐरे से कोई खास एलिमेंट हटाना चाहते हैं, तो delete मेथड इस्तेमाल कर सकते हैं, जो आर्गुमेंट के रूप में एक एलिमेंट लेता है।
यह मेथड हटाया गया एलिमेंट लौटाता है।
अगर वह एलिमेंट ऐरे में मौजूद न हो, तो nil लौटता है।
numbers = [1, 2, 3]
numbers.delete(2) # => 2
numbers # => [1, 3]
first & last
ऐरे का पहला या अंतिम एलिमेंट पाने के लिए आप first और last मेथड इस्तेमाल कर सकते हैं।
ये मेथड एक वैकल्पिक आर्गुमेंट लेते हैं, जो बताता है कि कितने एलिमेंट लौटाने हैं।
इंडेक्स 0 या -1 इस्तेमाल करने या किसी रेंज का सहारा लेने के मुकाबले ये कोड को पढ़ने में ज़्यादा आसान बनाते हैं।
अगर ऐरे खाली हो, तो कोड Enumerable::EmptyError उठाता है।
numbers = [1, 2, 3]
numbers.first # => 1
numbers.last # => 3
numbers.first(2) # => [1, 2]
numbers.last(2) # => [2, 3]
empty_array = [] of Int32
empty_array.last # => Error: Empty enumerable (Enumerable::EmptyError)
reverse
ऐरे को उलटने के लिए आप reverse मेथड इस्तेमाल कर सकते हैं, जो एलिमेंट को उल्टे क्रम में रखकर एक नया ऐरे लौटाता है।
ध्यान दीजिए कि reverse एक नया ऐरे लौटाता है और मूल ऐरे को नहीं बदलता।
अगर आप मूल ऐरे को बदलना चाहते हैं, तो मेथड के नाम के अंत में ! लगाइए।
numbers = [1, 2, 3]
numbers.reverse # => [3, 2, 1]
numbers # => [1, 2, 3]
numbers.reverse! # => [3, 2, 1]
numbers # => [3, 2, 1]
Concat(+)
ऐरे में ऑब्जेक्ट जोड़ने के लिए append मेथड (<<) काम आता है।
लेकिन जब दो ऐरे जोड़ने हों, तो आप + ऑपरेटर इस्तेमाल कर सकते हैं, जो दोनों ऐरे के एलिमेंट लेकर एक नया ऐरे लौटाता है।
[1, 2] + [3, 4] # => [1, 2, 3, 4]
अगर आप एक ऐरे को दूसरे ऐरे में जोड़ते हैं, तो वह पूरा ऐरे एक ही एलिमेंट के रूप में जुड़ता है।
[1, 2] << [3, 4] # => [1, 2, [3, 4]]
empty?
ऐरे खाली है या नहीं, यह जाँचने के लिए आप empty? मेथड इस्तेमाल कर सकते हैं, जो ऐरे खाली होने पर true और वरना false लौटाता है।
ऐरे की लंबाई की 0 से तुलना करने के मुकाबले यह कोड को पढ़ने में ज़्यादा आसान बनाता है।
[].empty? # => true
[1, 2, 3].empty? # => false
index
जब आप ऐरे में किसी एलिमेंट का इंडेक्स जानना चाहते हैं, तो index मेथड इस्तेमाल कर सकते हैं, जो आर्गुमेंट के रूप में एक एलिमेंट लेता है।
अगर वह एलिमेंट ऐरे में मौजूद न हो, तो nil लौटता है।
numbers = [1, 2, 3]
numbers.index(2) # => 1
size
जब आप जानना चाहते हैं कि ऐरे में कितने एलिमेंट हैं, तो size मेथड इस्तेमाल कर सकते हैं।
numbers = [1, 2, 3]
numbers.size # => 3
count
जब आप गिनना चाहते हैं कि कोई एलिमेंट ऐरे में कितनी बार मौजूद है, तो count मेथड इस्तेमाल कर सकते हैं।
fruits = ["apple", "banana", "apple"]
fruits.count("apple") # => 2
fruits.count("banana") # => 1
fruits.count("watermelon") # => 0
sort
जब आप ऐरे को क्रम में लगाना चाहते हैं, तो sort मेथड इस्तेमाल कर सकते हैं, जो एलिमेंट को क्रम में लगाकर एक नया ऐरे लौटाता है।
reverse की तरह यह मेथड भी एक नया ऐरे लौटाता है और मूल ऐरे को नहीं बदलता।
numbers = [3, 2, 1]
numbers.sort # => [1, 2, 3]
numbers # => [3, 2, 1]
numbers.sort! # => [1, 2, 3]
numbers # => [1, 2, 3]
सीखने का अभ्यास
