भाषाओं की सूची

ऐरे एक म्यूटेबल डेटा स्ट्रक्चर है, जो किसी एक खास टाइप के एलिमेंट का संग्रह रखता है। ऐरे ऐसा डेटा स्ट्रक्चर है जिसे इंडेक्स से एक्सेस किया जा सकता है। ऐरे के म्यूटेबल होने का मतलब है कि अगर ऐरे पर कोई ऐसा मेथड कॉल किया जाए जो उसे बदल देता है, तो ऐरे बदल जाता है। यानी यह नया ऐरे नहीं बनाता, बल्कि मौजूद ऐरे को ही बदल देता है।

ऐरे बनाने के लिए ऐरे लिटरल लिखने का सिंटैक्स ([]) इस्तेमाल कीजिए। इसके अंदर ऐरे के एलिमेंट को कॉमा से अलग करके लिखिए।

[1, 2, 3] # => [1, 2, 3]

Crystal ऐरे के एलिमेंट से उसका टाइप अनुमान लगा लेता है।

[1, 2, 3].class # => Array(Int32)

मल्टी-टाइप ऐरे

हालाँकि पहले बताया गया है कि ऐरे एक ही टाइप के एलिमेंट का संग्रह होता है, फिर भी यूनियन टाइप की मदद से आप अलग-अलग टाइप वाला ऐरे बना सकते हैं। इससे ऐरे में यूनियन टाइप में दिए गए किसी भी टाइप के एलिमेंट रखे जा सकते हैं। Crystal ऐरे के एलिमेंट से उसका टाइप अनुमान लगा लेता है।

[1, "2", 3.0] # => [1, "2", 3.0]

[1, "2", 3.0].class # => Array(Int32 | Float64 | String)

मल्टी-डाइमेंशनल ऐरे

मल्टी-डाइमेंशनल ऐरे, ऐरे का ऐरे होता है। यानी ऐरे का हर एलिमेंट खुद एक ऐरे होता है। जब आपको डेटा टेबल के रूप में रखना हो, तब यह काम आ सकता है। मल्टी-डाइमेंशनल ऐरे बनाने के लिए आप या तो ऐरे का ऐरे लिटरल लिख सकते हैं, या Array.new कंस्ट्रक्टर इस्तेमाल कर सकते हैं।

[[1, 2], [3, 4]]                    # => [[1, 2], [3, 4]]
numbers = Array(Array(Int32)).new() # => []
numbers << [1, 2]                   # => [[1, 2]]

ऐरे में एलिमेंट जोड़ना

ऐरे में एलिमेंट जोड़ने के लिए << (एपेंड) ऑपरेटर इस्तेमाल कीजिए।

[1, 2, 3] << 4 # => [1, 2, 3, 4]

आप जो एलिमेंट जोड़ना चाहते हैं, उसका टाइप ऐरे के टाइप जैसा ही होना चाहिए। अगर ऐसा न हो, तो एरर आ जाती है।

numbers : Array(Int32 | Float64) = [1, 2, 3]
numbers << 4.0
numbers # => [1, 2, 3, 4.0]

numbers << "5" # => Error: no overload matches 'Array(Int32 | Float64)#<<' with type String

ऐरे का साइज़

String की तरह, ऐरे का साइज़ भी size मेथड से पता किया जा सकता है।

[1, 2, 3].size # => 3

खाली ऐरे

खाली ऐरे बनाते समय कंपाइलर ऐरे का टाइप अनुमान नहीं लगा सकता। इसलिए आपको ऐरे का टाइप बताना पड़ता है। इसके लिए आप ऐरे का टाइप बता सकते हैं, of कीवर्ड इस्तेमाल कर सकते हैं, या ऐरे का इनिशलाइज़र सिंटैक्स Array(T).new इस्तेमाल कर सकते हैं।

[] of (Int32 | Float64 | String)    # => []
Array(Int32 | Float64 | String).new # => []

एलिमेंट एक्सेस करना

String की तरह, ऐरे के एलिमेंट को आप [] (इंडेक्स) ऑपरेटर से एक्सेस कर सकते हैं। इसके लिए उस एलिमेंट का इंडेक्स देना होता है जिसे आप एक्सेस करना चाहते हैं। अगर इंडेक्स सीमा से बाहर हो, तो IndexError एरर आ जाती है।

[1, 2, 3][0] # => 1

[1, 2, 3][3] # => Index out of bounds (IndexError)

रेंज की मदद से भी एलिमेंट एक्सेस किए जा सकते हैं।

[1, 2, 3][0..1] # => [1, 2]

रेंज से ऐरे बनाना

रेंज से ऐरे बनाने के लिए to_a मेथड इस्तेमाल कीजिए। जब आपको संख्याओं का ऐरे बनाना हो, तब यह काम आ सकता है।

(1..3).to_a # => [1, 2, 3]

स्ट्रिंग से ऐरे बनाना

स्ट्रिंग से ऐरे बनाने के लिए split मेथड इस्तेमाल कीजिए। इससे आप एक डेलिमिटर की मदद से स्ट्रिंग को स्ट्रिंग के ऐरे में तोड़ सकते हैं।

"1,2,3".split(",") # => ["1", "2", "3"]

chars मेथड से स्ट्रिंग के अक्षरों का ऐरे भी निकाला जा सकता है।

"123".chars # => ['1', '2', '3']

Char या String के ऐरे को String में बदलने के लिए आप join मेथड इस्तेमाल कर सकते हैं, जो आर्गुमेंट के तौर पर एक डेलिमिटर लेता है।

['1', '2', '3'].join(".") # => "1.2.3"

ऐरे से एलिमेंट हटाना

जब आप ऐरे के अंत से कोई एलिमेंट हटाना चाहते हैं, तो pop मेथड इस्तेमाल कर सकते हैं। यह एक ऑप्शनल आर्गुमेंट लेता है, जिसमें बताया जाता है कि ऐरे के अंत से कितने एलिमेंट हटाने हैं। यह मेथड वह एलिमेंट लौटाता है जो हटाया गया था। अगर ऐरे खाली हो, तो IndexError एरर आ जाती है।

numbers = [1, 2, 3]
numbers.pop # => 3
numbers     # => [1, 2]

empty_numbers = [] of Int32
empty_numbers.pop # => Index out of bounds (IndexError)

जब आप ऐरे से किसी खास इंडेक्स का एलिमेंट हटाना चाहते हैं, तो delete_at मेथड इस्तेमाल कर सकते हैं, जो आर्गुमेंट के तौर पर उस एलिमेंट का इंडेक्स लेता है जिसे हटाना है। अगर ऐरे खाली हो, तो IndexError एरर आ जाती है।

numbers = [1, 2, 3]
numbers.delete_at(1) # => 2
numbers              # => [1, 3]

empty_numbers = [] of Int32
empty_numbers.delete_at(0) # => Index out of bounds (IndexError)

ऐरे में वैल्यू बदलना

जब आप ऐरे में किसी खास इंडेक्स के एलिमेंट को बदलना चाहते हैं, तो []= (इंडेक्स असाइन) ऑपरेटर इस्तेमाल कर सकते हैं, जो आर्गुमेंट के तौर पर उस एलिमेंट का इंडेक्स और नई वैल्यू लेता है। अगर इंडेक्स सीमा से बाहर हो, तो IndexError एरर आ जाती है।

numbers = [1, 2, 3]
numbers[1] = 4
numbers # => [1, 4, 3]

numbers[3] = 5 # => Index out of bounds (IndexError)