Bagaimana anda tambahkan array ke array lain di Ruby dan tidak berakhir dengan multi-dimensi hasilnya?

Anda've punya ide yang bisa diterapkan, tapi #meratakan! adalah di tempat yang salah-itu merata penerima, sehingga anda bisa menggunakannya untuk mengubah[1, 2, ['foo', 'bar']] menjadi [1,2,'foo','bar'].

I'm pasti melupakan beberapa pendekatan, tetapi anda dapat menggabungkan:

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

atau tambahkan/append:

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

atau sambatan:

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

atau append dan meratakan:

(a1 

Anda hanya dapat menggunakan + operator!

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]

Anda dapat membaca semua tentang kelas array berikut: http://ruby-doc.org/core/classes/Array.html

Terbersih pendekatan adalah dengan menggunakan Array#concat metode; itu tidak akan membuat array baru (tidak seperti Array#+ yang akan melakukan hal yang sama tetapi membuat array baru).

Langsung dari dokumen (http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat):

concat(other_ary)

Menambahkan unsur-unsur other_ary untuk mandiri.

Jadi

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

Array#concat tidak akan meratakan sebuah array multidimensi jika dilewatkan sebagai argumen. Anda'll perlu menangani secara terpisah:

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

Terakhir, anda dapat menggunakan kami corelib permata (https://github.com/corlewsolutions/corelib) yang menambahkan pembantu yang berguna untuk Ruby kelas inti. Khususnya kita memiliki Array#add_all metode yang secara otomatis akan meratakan array multidimensi sebelum melaksanakan concat.

Mencoba ini, itu akan menggabungkan array anda menghapus duplikat

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

array3 = array1|array2

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

Dokumentasi lebih lanjut lihat "Uni"

Mudah metode yang bekerja dengan versi Ruby >= 2.0 tapi tidak dengan versi yang lebih tua :

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]

Berikut adalah dua cara, perilaku dalam hal ini yang pertama dengan cara memberikan sebuah array baru ( diterjemahkan ke somearray = somearray + anotherarray )

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

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

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

(array1 + array2).uniq

Dengan cara ini anda mendapatkan array1 elemen pertama. Anda akan mendapatkan tidak ada duplikat.

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

Untuk menambahkan b untuk a dan menyimpan hasilnya dalam a:

a.push(*b)

atau

a += b

Dalam kedua kasus, a menjadi:

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

tapi dalam kasus yang pertama, unsur-unsur b yang ditambahkan ke yang ada a array, dan dalam kasus terakhir dua array yang digabungkan bersama-sama dan hasilnya disimpan dalam a.

Mengelaborasi @Pilcrow's jawaban yang hanya cocok untuk menjawab besar array adalah concat (+) karena lebih cepat dan tidak mengalokasikan objek baru yang akan mengumpulkan sampah ketika beroperasi di dalam lingkaran.

Berikut ini's benchmark:

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

Hasil:

       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 ': stack level too deep (SystemStackError)

Seperti yang anda lihat menggunakan push melempar ERROR: stack tingkat terlalu dalam (SystemStackError) ketika array yang cukup besar.

Hanya cara lain untuk melakukan hal itu.

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

Pertanyaannya, pada dasarnya, adalah "bagaimana untuk menggabungkan array di Ruby". Tentu jawabannya adalah dengan menggunakan concat atau + seperti yang disebutkan di hampir setiap jawaban.

Perpanjangan alami untuk pertanyaan akan menjadi "bagaimana untuk melakukan row-wise rangkaian dari 2D array di Ruby". Ketika saya mencari di google "ruby menggabungkan matriks", ini JADI pertanyaan adalah hasil atas jadi saya pikir saya akan meninggalkan jawaban saya untuk pertanyaan itu (tanpa diminta, tetapi terkait) pertanyaan berikut ini untuk anak cucu.

Dalam beberapa aplikasi, anda mungkin ingin "menggabungkan" dua array 2D row-wise. Sesuatu seperti,

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

Ini adalah sesuatu seperti "menambah" matriks. Untuk contoh, saya menggunakan teknik ini untuk membuat satu adjacency matrix untuk mewakili grafik dari sekelompok kecil matrik. Tanpa teknik ini saya akan memiliki untuk iterate atas komponen-komponen dalam sebuah cara yang bisa saja rawan kesalahan atau frustasi untuk berpikir tentang. Saya mungkin harus melakukan each_with_index, misalnya. Bukannya aku dikombinasikan zip dan meratakan sebagai berikut,

# 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]]

Jika data baru yang bisa menjadi sebuah array atau skalar, dan anda ingin mencegah data baru untuk bersarang jika itu array, splat operator adalah awesome! Kembali skalar untuk suatu skalar, dan membongkar daftar argumen untuk sebuah array.

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 

["c", "sesuatu"] + ["lain" + "sesuatu"]

I'm heran tidak ada yang menyebutkan mengurangi, yang bekerja dengan baik ketika anda memiliki sebuah array dari array:

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

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

Ini won't menghapus dups, tapi

a|b

menghilangkan dups.

Saya merasa lebih mudah untuk mendorong atau menambahkan array dan kemudian meratakan mereka di tempat, seperti:

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

somearray = ["c", "sesuatu"]

anotherarray = ["lain", "sesuatu"]

somearray + anotherarray