Ruby Language
Arrays

वाक्य - विन्यास

• a = [] # सरणी शाब्दिक का उपयोग करते हुए
• a = Array.new # शाब्दिक प्रयोग करने के बराबर
• a = Array.new (5) # शून्य के मान के साथ 5 तत्वों के साथ एक सरणी बनाएँ।
• a = Array.new (5, 0) # 0 के डिफ़ॉल्ट मान के साथ 5 तत्वों के साथ एक सरणी बनाएं।

#नक्शा

#map द्वारा प्रदान किया गया #map , प्रत्येक तत्व पर एक ब्लॉक लागू करके और परिणाम एकत्रित करके एक सरणी बनाता है:

[1, 2, 3].map { |i| i * 3 }
# => [3, 6, 9]

['1', '2', '3', '4', '5'].map { |i| i.to_i }
# => [1, 2, 3, 4, 5]

मूल सरणी संशोधित नहीं है; नया सरणी स्रोत मानों के रूप में उसी क्रम में रूपांतरित मानों के साथ लौटाया जाता है। map! यदि आप मूल सरणी को संशोधित करना चाहते हैं तो इसका उपयोग किया जा सकता है।

map विधि में आप विधि को कॉल कर सकते हैं या सरणी में सभी तत्वों के लिए खरीद का उपयोग कर सकते हैं।

# call to_i method on all elements
%w(1 2 3 4 5 6 7 8 9 10).map(&:to_i)
# => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# using proc (lambda) on all elements
%w(1 2 3 4 5 6 7 8 9 10).map(&->(i){ i.to_i * 2})
# => [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

map collect का पर्याय है।

शाब्दिक निर्माणकर्ता के साथ एक एरियर बनाना []

वर्ग कोष्ठक ( [ और ] ) में तत्वों की एक सूची संलग्न करके ऐरे बनाए जा सकते हैं। इस संकेतन के एरे तत्वों को अल्पविराम से अलग किया जाता है:

array = [1, 2, 3, 4]

Arrays किसी भी संयोजन में किसी भी प्रकार की वस्तुओं को शामिल कर सकता है जिसमें कोई प्रतिबंध नहीं है:

array = [1, 'b', nil, [3, 4]]

स्ट्रिंग्स की सरणी बनाएँ

रूबी के प्रतिशत स्ट्रिंग सिंटैक्स का उपयोग करके तारों के ऐरे बनाए जा सकते हैं:

array = %w(one two three four)

यह कार्यात्मक रूप से सरणी को परिभाषित करने के बराबर है:

array = ['one', 'two', 'three', 'four']

%w() बजाय आप अन्य मिलान जोड़े का उपयोग कर सकते हैं: %w{...} , %w[...] या %w<...> ।

मनमाना गैर-अल्फ़ान्यूमेरिक सीमांकक का उपयोग करना भी संभव है, जैसे: %w!...! , %w#...# या %w@...@ ।

स्ट्रिंग इंटरपोलेशन को शामिल करने के लिए %w बजाय %W का उपयोग किया जा सकता है। निम्नलिखित को धयान मे रखते हुए:

var = 'hello'

%w(#{var}) # => ["\#{var}"]
%W(#{var}) # => ["hello"]

एक के साथ अंतरिक्ष से बचकर एकाधिक शब्दों की व्याख्या की जा सकती है।

%w(Colorado California New\ York) # => ["Colorado", "California", "New York"]

प्रतीकों का सरणी बनाएँ

array = %i(one two three four)

सरणी [:one, :two, :three, :four] बनाता है।

%i(...) बजाय, आप %i{...} या %i[...] या %i!...! उपयोग कर सकते हैं %i!...!

इसके अतिरिक्त, यदि आप प्रक्षेप का उपयोग करना चाहते हैं, तो आप %I साथ ऐसा कर सकते हैं।

a = 'hello'
b = 'goodbye'
array_one = %I(#{a} #{b} world)
array_two = %i(#{a} #{b} world)

सरणियाँ बनाता है: array_one = [:hello, :goodbye, :world] और array_two = [:"\#{a}", :"\#{b}", :world]

ऐरे से ऐरे बनाएँ :: नया

एक खाली ऐरे ( [] ) को ऐरे की कक्षा विधि से बनाया जा सकता है, Array::new :

Array.new    

सरणी की लंबाई निर्धारित करने के लिए, एक संख्यात्मक तर्क पास करें:

Array.new 3 #=> [nil, nil, nil]

डिफ़ॉल्ट मान के साथ किसी सरणी को पॉप्युलेट करने के दो तरीके हैं:

• दूसरे तर्क के रूप में एक अपरिवर्तनीय मूल्य पास करें।
• एक ब्लॉक पास करें जो वर्तमान सूचकांक प्राप्त करता है और उत्परिवर्तनीय मान उत्पन्न करता है।

Array.new 3, :x #=> [:x, :x, :x]

Array.new(3) { |i| i.to_s } #=> ["0", "1", "2"]

a = Array.new 3, "X"            # Not recommended.
a[1].replace "C"                # a => ["C", "C", "C"]

b = Array.new(3) { "X" }        # The recommended way.
b[1].replace "C"                # b => ["X", "C", "X"]

मनमाने ढंग से ऐरे एलिमेंट्स

तत्वों को जोड़ना:

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

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

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

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

तत्वों को हटाना:

array = [1, 2, 3, 4]
array.pop
# => 4
array
# => [1, 2, 3]

array = [1, 2, 3, 4]
array.shift
# => 1
array
# => [2, 3, 4]

array = [1, 2, 3, 4]
array.delete(1)
# => 1
array
# => [2, 3, 4]

array = [1,2,3,4,5,6]
array.delete_at(2) // delete from index 2
# => 3  
array 
# => [1,2,4,5,6] 


array = [1, 2, 2, 2, 3]
array - [2]
# => [1, 3]    # removed all the 2s
array - [2, 3, 4]
# => [1]       # the 4 did nothing

संयुक्त सरणियाँ:

[1, 2, 3] + [4, 5, 6]
# => [1, 2, 3, 4, 5, 6]

[1, 2, 3].concat([4, 5, 6])
# => [1, 2, 3, 4, 5, 6]

[1, 2, 3, 4, 5, 6] - [2, 3]
# => [1, 4, 5, 6]

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

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

आप उदाहरण के लिए, सरणियों को गुणा भी कर सकते हैं

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

संघ, चौराहे और अंतर को व्यवस्थित करता है

x = [5, 5, 1, 3]
y = [5, 2, 4, 3]

संघ ( | ) में दोनों सरणियों के तत्व शामिल हैं, डुप्लिकेट को हटा दिया गया है:

x | y
=> [5, 1, 3, 2, 4]

अंतःशिरा ( & ) में ऐसे तत्व होते हैं जो पहले और दूसरे सरणी में मौजूद होते हैं:

x & y
=> [5, 3]

अंतर ( - ) में ऐसे तत्व शामिल हैं जो पहले सरणी में मौजूद हैं और दूसरे सरणी में मौजूद नहीं हैं:

x - y
=> [1]

फ़िल्टरिंग सरणियाँ

अक्सर हम केवल एक सरणी के तत्वों पर काम करना चाहते हैं जो एक विशिष्ट स्थिति को पूरा करते हैं:

चुनते हैं

उन तत्वों को लौटाएगा जो एक विशिष्ट स्थिति से मेल खाते हैं

array = [1, 2, 3, 4, 5, 6]
array.select { |number| number > 3 } # => [4, 5, 6]

अस्वीकार

ऐसे तत्व लौटाएंगे जो किसी विशिष्ट स्थिति से मेल नहीं खाते हैं

array = [1, 2, 3, 4, 5, 6]
array.reject { |number| number > 3 } # => [1, 2, 3]

#select और #reject दोनों एक सरणी #reject हैं, इसलिए उन्हें जंजीर दी जा सकती है:

array = [1, 2, 3, 4, 5, 6]
array.select { |number| number > 3 }.reject { |number| number < 5 }
  # => [5, 6]

इंजेक्ट करें, कम करें

इंजेक्ट और कम करना एक ही चीज के अलग-अलग नाम हैं। अन्य भाषाओं में इन कार्यों को अक्सर सिलवटों (जैसे गुना या तह) कहा जाता है। ये विधियाँ प्रत्येक एन्यूमरेबल ऑब्जेक्ट पर उपलब्ध हैं।

इंजेक्ट एक दो तर्क फ़ंक्शन लेता है और लागू होता है कि एरे में तत्वों के सभी जोड़े के लिए।

सरणी [1, 2, 3] हम इन सभी को एक साथ जोड़ सकते हैं शून्य के शुरुआती मूल्य के साथ एक शुरुआती मूल्य निर्दिष्ट करके और इतने पर ब्लॉक करें:

[1,2,3].reduce(0) {|a,b| a + b} # => 6

यहां हम फ़ंक्शन को एक प्रारंभिक मूल्य और एक ब्लॉक पास करते हैं जो सभी मानों को एक साथ जोड़ने के लिए कहता है। ब्लॉक पहले से चलाया जाता है 0 के रूप में a और 1 के रूप में b यह तो अगले के रूप में इस बात का परिणाम लेता है a तो हम तो जोड़ रहे हैं 1 दूसरी मूल्य के लिए 2 । फिर हम कि (का नतीजा ले 3 ) और कहा कि जोड़ने सूची (भी में अंतिम तत्व के लिए पर 3 ) हमें हमारे परिणाम (दे रही है 6 )।

हम पहले तर्क को छोड़ देते हैं, तो यह सेट हो जाएगा a , सूची में पहले तत्व जा रहा है ताकि उपरोक्त उदाहरण के रूप में ही है:

[1,2,3].reduce {|a,b| a + b} # => 6

इसके अलावा, एक फ़ंक्शन के साथ एक ब्लॉक पास करने के बजाय, हम एक नामित फ़ंक्शन को प्रतीक के रूप में पारित कर सकते हैं, या तो शुरुआती मूल्य के साथ, या बिना। इसके साथ, उपरोक्त उदाहरण के रूप में लिखा जा सकता है:

[1,2,3].reduce(0, :+) # => 6

या शुरुआती मूल्य को छोड़ देना:

[1,2,3].reduce(:+) # => 6

तत्वों तक पहुंचना

आप किसी सरणी के तत्वों को उनके सूचकांकों द्वारा एक्सेस कर सकते हैं। ऐरे इंडेक्स नंबरिंग 0 से शुरू होती है।

%w(a b c)[0] # => 'a'
%w(a b c)[1] # => 'b'

आप रेंज का उपयोग करके एक सरणी फसल कर सकते हैं

%w(a b c d)[1..2] # => ['b', 'c'] (indices from 1 to 2, including the 2)
%w(a b c d)[1...2] # => ['b'] (indices from 1 to 2, excluding the 2)

यह एक नया सरणी देता है, लेकिन मूल को प्रभावित नहीं करता है। रूबी नकारात्मक सूचकांकों के उपयोग का भी समर्थन करती है।

%w(a b c)[-1] # => 'c'
%w(a b c)[-2] # => 'b'

आप नकारात्मक और सकारात्मक सूचकांकों को भी जोड़ सकते हैं

%w(a b c d e)[1...-1] # => ['b', 'c', 'd']

अन्य उपयोगी विधियां

सरणी में पहले तत्व का उपयोग करने के लिए first का उपयोग करें:

[1, 2, 3, 4].first # => 1

या first(n) सरणी में लौटे पहले n तत्वों को एक्सेस करने के लिए:

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

इसी तरह last और last(n) :

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

किसी सरणी में यादृच्छिक तत्व तक पहुंचने के लिए sample का उपयोग करें:

[1, 2, 3, 4].sample  # => 3
[1, 2, 3, 4].sample  # => 1

या sample(n) :

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

द्वि-आयामी सरणी

Array::new कंस्ट्रक्टर का उपयोग करके, आप किसी दिए गए आकार के साथ एक सरणी और इसके प्रत्येक स्लॉट में एक नई सरणी को इनिशियलाइज़ कर सकते हैं। आंतरिक सरणियों को एक आकार और और प्रारंभिक मूल्य भी दिया जा सकता है।

उदाहरण के लिए, शून्य की 3x4 सरणी बनाने के लिए:

array = Array.new(3) { Array.new(4) { 0 } }

p साथ मुद्रित होने पर ऊपर उत्पन्न सरणी इस तरह दिखाई देती है:

[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

आप इस तरह के तत्वों को पढ़ या लिख सकते हैं:

x = array[0][1]
array[2][3] = 2

एरेस और स्पैट (*) ऑपरेटर

* ऑपरेटर को चर और सरणियों को अनपैक करने के लिए इस्तेमाल किया जा सकता है ताकि उन्हें एक विधि के लिए व्यक्तिगत तर्क के रूप में पारित किया जा सके।

यदि यह पहले से ही नहीं है, तो एक एरे में किसी एक वस्तु को लपेटने के लिए इसका उपयोग किया जा सकता है:

def wrap_in_array(value)
  [*value]
end

wrap_in_array(1)
#> [1]

wrap_in_array([1, 2, 3])
#> [1, 2, 3]

wrap_in_array(nil)
#> []

उपरोक्त उदाहरण में, wrap_in_array विधि एक तर्क, value स्वीकार करती है।

यदि value एक Array , तो इसके तत्व अनपैक किए जाते हैं और उन तत्वों से युक्त एक नया सरणी बनाया जाता है।

यदि value एक एकल ऑब्जेक्ट है, तो उस एकल ऑब्जेक्ट से युक्त एक नया सरणी बनाया जाता है।

यदि value nil , तो खाली सरणी लौटा दी जाती है।

कुछ मामलों में विधियों में एक तर्क के रूप में उपयोग किए जाने पर विशेष रूप से स्पैट ऑपरेटर काम में आता है। उदाहरण के लिए, यह nil , एकल मूल्यों और सरणियों को सुसंगत तरीके से नियंत्रित करने की अनुमति देता है:

def list(*values)
  values.each do |value|
    # do something with value
    puts value
  end
end

list(100)
#> 100

list([100, 200])
#> 100
#> 200

list(nil)
# nothing is outputted

सड़न

किसी भी सरणी को उसके तत्वों को कई चर में निर्दिष्ट करके जल्दी से विघटित किया जा सकता है। एक सरल उदाहरण:

arr = [1, 2, 3]
# ---
a = arr[0]
b = arr[1]
c = arr[2]
# --- or, the same
a, b, c = arr

सूचक ऑपरेटर (के साथ एक चर पूर्ववर्ती * ) यह में रखता है सभी तत्वों है कि अन्य चर द्वारा कब्जा कर लिया नहीं किया गया है की एक सरणी। यदि कोई नहीं बचा है, तो खाली सरणी असाइन की गई है। एक ही असाइनमेंट में केवल एक स्पैट का उपयोग किया जा सकता है:

a, *b = arr       # a = 1; b = [2, 3]
a, *b, c = arr    # a = 1; b = [2]; c = 3
a, b, c, *d = arr # a = 1; b = 2; c = 3; d = []
a, *b, *c = arr   # SyntaxError: unexpected *

अपघटन सुरक्षित है और त्रुटियों को कभी नहीं बढ़ाता है। nil s को असाइन किया गया है जहाँ पर्याप्त तत्व नहीं हैं, [] ऑपरेटर के व्यवहार से मेल खाते हुए जब एक सूचकांक को सीमा से बाहर पहुँचा जाता है:

arr[9000] # => nil
a, b, c, d = arr # a = 1; b = 2; c = 3; d = nil

अपघटन ऑब्जेक्ट को असाइन किए जाने पर to_ary को कॉल करने का प्रयास करता है। इस पद्धति को अपने प्रकार में लागू करने से आपको इसे विघटित करने की क्षमता मिलती है:

class Foo
  def to_ary
    [1, 2]
  end
end
a, b = Foo.new # a = 1; b = 2

यदि ऑब्जेक्ट विघटित हो रहा है, तो respond_to? नहीं करता है respond_to? to_ary , इसे एकल-तत्व सरणी के रूप में माना जाता है:

1.respond_to?(:to_ary) # => false
a, b = 1 # a = 1; b = nil

अपघटन भी एक () -डेलिफ़ाइड अपघटन अभिव्यक्ति का उपयोग करके नेस्टेड किया जा सकता है जो अन्यथा एक एकल तत्व होगा:

arr = [1, [2, 3, 4], 5, 6]
a, (b, *c), *d = arr # a = 1; b = 2; c = [3, 4]; d = [5, 6]
#   ^^^^^

यह प्रभावी रूप से स्पैट के विपरीत है।

वास्तव में, किसी भी अपघटन अभिव्यक्ति को () द्वारा सीमांकित किया जा सकता है। लेकिन पहले स्तर के लिए अपघटन वैकल्पिक है।

a, b = [1, 2]
(a, b) = [1, 2] # the same thing

बढ़त का मामला: एक एकल पहचानकर्ता को विनाशकारी पैटर्न के रूप में इस्तेमाल नहीं किया जा सकता है, यह बाहरी या एक नेस्टेड हो:

(a) = [1] # SyntaxError
a, (b) = [1, [2]] # SyntaxError

एक विनाशकारी अभिव्यक्ति के लिए एक सरणी शाब्दिक निर्दिष्ट करते समय, बाहरी [] छोड़ा जा सकता है:

a, b = [1, 2]
a, b =  1, 2  # exactly the same

इसे समानांतर असाइनमेंट के रूप में जाना जाता है, लेकिन यह हुड के नीचे समान अपघटन का उपयोग करता है। यह अतिरिक्त अस्थायी चर को नियोजित किए बिना चर के मानों के आदान-प्रदान के लिए विशेष रूप से आसान है:

t = a; a = b; b = t # an obvious way
a, b = b, a         # an idiomatic way
(a, b) = [b, a]     # ...and how it works

असाइनमेंट के दाईं ओर निर्माण करते समय मानों पर कब्जा कर लिया जाता है, इसलिए स्रोत और गंतव्य के समान चर का उपयोग करना अपेक्षाकृत सुरक्षित है।

बहु-आयामी सरणी को एक-आयामी (चपटा) सरणी में बदल दें

[1, 2, [[3, 4], [5]], 6].flatten  # => [1, 2, 3, 4, 5, 6]

यदि आपके पास एक बहुआयामी सरणी है और आपको इसे एक सरल (यानी एक आयामी) सरणी बनाने की आवश्यकता है, तो आप #flatten विधि का उपयोग कर सकते हैं।

अद्वितीय सरणी तत्व प्राप्त करें

यदि आपको किसी ऐसे मामले को पढ़ने की आवश्यकता है जिसमें आप दोहराव से बचने के तत्वों का उपयोग करते हैं तो आप #uniq विधि का उपयोग करें:

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq
#=> [1, 2, 3, 4, 5]

इसके बजाय, यदि आप किसी डुप्लिकेट से सभी डुप्लिकेट तत्वों को निकालना चाहते हैं, तो आप #uniq! उपयोग कर सकते हैं #uniq! तरीका:

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq!
#=> [1, 2, 3, 4, 5]

जबकि आउटपुट समान है, #uniq! नए सरणी को भी संग्रहीत करता है:

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq
#=> [1, 2, 3, 4, 5]
a
#=> [1, 1, 2, 3, 4, 4, 5]

a = [1, 1, 2, 3, 4, 4, 5]
a.uniq!
#=> [1, 2, 3, 4, 5]
a
#=> [1, 2, 3, 4, 5]

किसी सरणी के सभी संयोजन / क्रमपरिवर्तन प्राप्त करें

permutation विधि, जब एक ब्लॉक के साथ बुलाया जाता है, दो आयामी सरणी देता है जिसमें संख्याओं के संग्रह के सभी क्रमबद्ध अनुक्रम होते हैं।

यदि इस पद्धति को बिना ब्लॉक के कहा जाता है, तो यह एक enumerator लौटाएगा। किसी सरणी में बदलने के लिए, to_a पद्धति को कॉल करें।

दूसरी ओर combination विधि, जब एक ब्लॉक के साथ बुलाया जाता है, तो दो-आयामी सरणी होती है जिसमें संख्याओं के संग्रह के सभी अनुक्रम शामिल होते हैं। क्रमपरिवर्तन के विपरीत, आदेश संयोजनों में अवहेलना है। उदाहरण के लिए, [1,2,3] [3,2,1] के समान है

संयोजन विधि को खुद से कॉल करने से परिणाम होगा। एक सरणी प्राप्त करने के लिए, to_a विधि को कॉल करें।

repeated_combination - repeated_permutation repeated_combination और repeated_permutation तरीके समान होते हैं, एक ही तत्व को छोड़कर कई बार दोहराया जा सकता है।

उदाहरण के लिए अनुक्रम [1,1] , [1,3,3,1] , [3,3,3] नियमित संयोजन और अनुमति में मान्य नहीं होंगे।

लगातार संख्याओं या अक्षरों का एक सरणी बनाएँ

Range ऑब्जेक्ट पर Enumerable#to_a को कॉल करके इसे आसानी से पूरा किया जा सकता है:

(1..10).to_a    #=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

(a..b) अर्थ है कि इसमें a और b के बीच के सभी नंबर शामिल होंगे। अंतिम संख्या को बाहर करने के लिए, a...b उपयोग करें

a_range = 1...5
a_range.to_a       #=> [1, 2, 3, 4]

या

('a'..'f').to_a    #=> ["a", "b", "c", "d", "e", "f"]
('a'...'f').to_a   #=> ["a", "b", "c", "d", "e"]

एक सरणी बनाने के लिए एक सुविधाजनक शॉर्टकट [*a..b]

[*1..10]           #=> [1,2,3,4,5,6,7,8,9,10]
[*'a'..'f']        #=> ["a", "b", "c", "d", "e", "f"]

# माइक्रोमैक्स के साथ एक सरणी से सभी शून्य तत्वों को निकालें

यदि एक सरणी में एक या अधिक nil तत्व होते हैं और इन्हें निकालने की आवश्यकता होती है, तो Array#compact या Array#compact! विधियों का उपयोग किया जा सकता है, नीचे के रूप में।

array = [ 1, nil, 'hello', nil, '5', 33]

array.compact # => [ 1, 'hello', '5', 33]

#notice that the method returns a new copy of the array with nil removed,
#without affecting the original

array = [ 1, nil, 'hello', nil, '5', 33]

#If you need the original array modified, you can either reassign it

array = array.compact # => [ 1, 'hello', '5', 33]

array = [ 1, 'hello', '5', 33]

#Or you can use the much more elegant 'bang' version of the method

array = [ 1, nil, 'hello', nil, '5', 33]

array.compact # => [ 1, 'hello', '5', 33]

array = [ 1, 'hello', '5', 33]

अंत में, ध्यान दें कि अगर #compact या #compact! किसी भी nil तत्वों के साथ एक सरणी पर कहा जाता है, ये शून्य वापस आ जाएंगे।

array = [ 'foo', 4, 'life']

array.compact # => nil

array.compact! # => nil

संख्या की सरणी बनाएँ

संख्याओं की एक सरणी बनाने का सामान्य तरीका:

numbers = [1, 2, 3, 4, 5]

रेंज ऑब्जेक्ट्स का उपयोग बड़े पैमाने पर संख्याओं की एक सरणी बनाने के लिए किया जा सकता है:

numbers = Array(1..10) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

numbers = (1..10).to_a # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#step और #map विधियाँ हमें संख्याओं की सीमा पर स्थितियाँ लागू करने की अनुमति देती हैं:

odd_numbers = (1..10).step(2).to_a # => [1, 3, 5, 7, 9]

even_numbers = 2.step(10, 2).to_a # => [2, 4, 6, 8, 10]

squared_numbers = (1..10).map { |number| number * number } # => [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

उपरोक्त सभी विधियां उत्सुकता से संख्याओं को लोड करती हैं। यदि आपको उन्हें आलसी लोड करना है:

number_generator = (1..100).lazy # => #<Enumerator::Lazy: 1..100>

number_generator.first(10) # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

किसी वस्तु से अर्रे को कास्ट करना

किसी भी ऑब्जेक्ट से ऐरे पाने के लिए, Kernel#Array उपयोग करें।

निम्नलिखित एक उदाहरण है:

Array('something') #=> ["something"]
Array([2, 1, 5])   #=> [2, 1, 5]
Array(1)           #=> [1]
Array(2..4)        #=> [2, 3, 4]
Array([])          #=> []
Array(nil)         #=> []

उदाहरण के लिए, आप निम्न कोड से join_as_string विधि को बदल सकते हैं

def join_as_string(arg)
  if arg.instance_of?(Array)
    arg.join(',')
  elsif arg.instance_of?(Range)
    arg.to_a.join(',')
  else
    arg.to_s
  end
end

join_as_string('something') #=> "something"
join_as_string([2, 1, 5])   #=> "2,1,5"
join_as_string(1)           #=> "1"
join_as_string(2..4)        #=> "2,3,4"
join_as_string([])          #=> ""
join_as_string(nil)         #=> ""

निम्नलिखित कोड के लिए।

def join_as_string(arg)
  Array(arg).join(',')
end