Ruby'de başka bir diziye bir dizi nasıl eklersiniz ve çok boyutlu bir sonuç elde edemezsiniz?

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

Tahmin etmiştim

["some","thing","another","thing"]

Uygulanabilir bir fikriniz var, ancak #flatten!yanlış yerde - alıcısını düzleştirir, böylece [1, 2, ['foo', 'bar']]dönüşmek için kullanabilirsiniz [1,2,'foo','bar'].

Şüphesiz bazı yaklaşımları unutuyorum, ancak birleştirebilirsiniz :

a1.concat a2
a1 + a2              # creates a new array, as does a1 += a2

veya başa ekle / ekle :

a1.push(*a2)         # note the asterisk
a2.unshift(*a1)      # note the asterisk, and that a2 is the receiver

veya ekleme :

a1[a1.length, 0] = a2
a1[a1.length..0] = a2
a1.insert(a1.length, *a2)

veya ekleyin ve düzleştirin :

(a1 << a2).flatten!  # a call to #flatten instead would return a new array

Sadece +operatörü kullanabilirsiniz !

irb(main):001:0> a = [1,2]
=> [1, 2]
irb(main):002:0> b = [3,4]
=> [3, 4]
irb(main):003:0> a + b
=> [1, 2, 3, 4]

Dizi sınıfıyla ilgili her şeyi buradan okuyabilirsiniz: http://ruby-doc.org/core/classes/Array.html

En temiz yaklaşım Array # concat yöntemini kullanmaktır; yeni bir dizi oluşturmaz (Array # + 'dan farklı olarak aynı şeyi yapar ancak yeni bir dizi oluşturur).

Doğrudan dokümanlardan ( http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat ):

concat (other_ary)

Other_ary öğelerini kendine ekler.

Yani

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

Array # concat , argüman olarak aktarılırsa çok boyutlu bir diziyi düzleştirmez. Bunu ayrıca ele almanız gerekir:

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

Son olarak, Ruby çekirdek sınıflarına yararlı yardımcılar ekleyen corelib gemimizi ( https://github.com/corlewsolutions/corelib ) kullanabilirsiniz . Özellikle, çok boyutlu dizileri concat gerçekleştirmeden önce otomatik olarak düzleştirecek bir Array # add_all yöntemimiz var.

Ruby sürüm> = 2.0 ile çalışan, ancak eski sürümlerle çalışmayan kolay yöntem:

irb(main):001:0> a=[1,2]
=> [1, 2]
irb(main):003:0> b=[3,4]
=> [3, 4]
irb(main):002:0> c=[5,6]
=> [5, 6]
irb(main):004:0> [*a,*b,*c]
=> [1, 2, 3, 4, 5, 6]

Bunu deneyin, yinelemeleri kaldırarak dizilerinizi birleştirir

array1 = ["foo", "bar"]
array2 = ["foo1", "bar1"]

array3 = array1|array2

http://www.ruby-doc.org/core/classes/Array.html

Diğer belgeler "Set Union" a bakınız

İşte iki yol, bu durumda ilk yolun yeni bir dizi atadığına dikkat edin (somearray = somearray + anotherarray anlamına gelir)

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray += anotherarray # => ["some", "thing", "another", "thing"]

somearray = ["some", "thing"]
somearray.concat anotherarray # => ["some", "thing", "another", "thing"]

a = ["some", "thing"]
b = ["another", "thing"]

Eklemek için biçin ave sonucu depolamak a:

a.push(*b)

veya

a += b

Her iki durumda da, aolur:

["some", "thing", "another", "thing"]

ancak önceki durumda, öğelerinin öğeleri bmevcut adiziye eklenir ve ikinci durumda iki dizi birleştirilir ve sonuç içinde depolanır a.

(array1 + array2).uniq

Bu şekilde önce array1 öğelerini alırsınız. Hiçbir kopya almazsınız.

@ Pilcrow'un cevabında, büyük diziler için tek uygun cevap concat(+ ) hızlıdır ve bir döngü içinde çalışırken çöp toplanacak yeni bir nesne ayırmaz.

Kıyaslama İşte:

require 'benchmark'

huge_ary_1 = Array.new(1_000_000) { rand(5_000_000..30_000_00) }

huge_ary_2 = Array.new(1_000_000) { rand(35_000_000..55_000_00) }

Benchmark.bm do |bm|
  p '-------------------CONCAT ----------------'
  bm.report { huge_ary_1.concat(huge_ary_2) }

  p '------------------- PUSH ----------------'
  bm.report { huge_ary_1.push(*huge_ary_2)  }
end

Sonuçlar:

       user     system      total        real
"-------------------CONCAT ----------------"
  0.000000   0.000000   0.000000 (  0.009388)
"------------------- PUSH ----------------"
  example/array_concat_vs_push.rb:13:in `block (2 levels) in <main>': stack level too deep (SystemStackError)

Gördüğünüz gibi, pushbir HATA atar : stack level too deep (SystemStackError)diziler yeterince büyük olduğunda.

Asıl soru "Ruby'de dizilerin nasıl birleştirileceği" sorusudur. Doğal olarak cevap kullanmak concatveya+ hemen hemen her cevapta belirtildiği gibidir.

Sorunun doğal bir uzantısı, “2B dizilerin Ruby'de satır bazında birleştirilmesinin nasıl gerçekleştirileceği” olacaktır. Ne zaman "yakut bitiştirmek matrisler" googled, bu SO soru en iyi sonuç oldu bu yüzden ben burada (sorulmamış ama ilgili) soruya gelecek kuşak için cevap bırakacağımı düşündüm.

Bazı uygulamalarda, iki 2D diziyi satır bazında "birleştirmek" isteyebilirsiniz. Gibi bir şey,

[[a, b], | [[x],    [[a, b, x],
 [c, d]] |  [y]] =>  [c, d, y]]

Bu bir matrisi "artırmak" gibidir. Örneğin, bu tekniği bir grup küçük matrisin grafiğini temsil eden tek bir bitişiklik matrisi oluşturmak için kullandım. Bu teknik olmasaydı, bileşenler üzerinde hataya eğilimli ya da düşünmek için sinir bozucu olabilecek bir şekilde yinelemeliydim. each_with_indexMesela bir yapmak zorunda kalabilirdim . Bunun yerine fermuar ve düzleştirmeyi aşağıdaki gibi birleştirdim ,

# given two multi-dimensional arrays that you want to concatenate row-wise
m1 = [[:a, :b], [:c, :d]]
m2 = [[:x], [:y]]

m1m2 = m1.zip(m2).map(&:flatten)
# => [[:a, :b, :x], [:c, :d, :y]]

Bunu yapmanın başka bir yolu.

[somearray, anotherarray].flatten
=> ["some", "thing", "another", "thing"]

["some", "thing"] + ["another" + "thing"]

Yeni veriler bir dizi veya skaler olabilirse ve yeni verilerin bir dizi olması durumunda iç içe geçmesini önlemek istiyorsanız, uyarıcı işleci harikadır! Bir skaler için bir skaler ve bir dizi için paketlenmemiş bir argüman listesi döndürür.

1.9.3-p551 :020 > a = [1, 2]
 => [1, 2] 
1.9.3-p551 :021 > b = [3, 4]
 => [3, 4] 
1.9.3-p551 :022 > c = 5
 => 5 
1.9.3-p551 :023 > a.object_id
 => 6617020 
1.9.3-p551 :024 > a.push *b
 => [1, 2, 3, 4] 
1.9.3-p551 :025 > a.object_id
 => 6617020 
1.9.3-p551 :026 > a.push *c
 => [1, 2, 3, 4, 5] 
1.9.3-p551 :027 > a.object_id
 => 6617020 

Kimsenin bahsetmediğine şaşırdım reduce, bir dizi diziniz olduğunda iyi çalışıyor:

lists = [["a", "b"], ["c", "d"]]
flatlist = lists.reduce(:+)  # ["a", "b", "c", "d"]

a = ['a', 'b']
b = ['c', 'd']
arr = [a, b].flatten

Bu, dup'leri kaldırmaz, ancak

a|b

dups kaldırır.

Dizileri itmeyi veya eklemeyi ve daha sonra bunları yerinde düzleştirmeyi daha kolay buluyorum:

somearray = ["some", "thing"]
anotherarray = ["another", "thing"]
somearray.push anotherarray # => ["some", "thing", ["another", "thing"]]
#or
somearray << anotherarray # => ["some", "thing", ["another", "thing"]]
somearray.flatten!  # => ["some", "thing", "another", "thing"]
somearray # => ["some", "thing", "another", "thing"]

somearray = ["bazı", "şey"]

anotherarray = ["başka bir", "şey"]

bir şey + anotherarray