Bagaimana Anda menambahkan array ke array lain di Ruby dan tidak berakhir dengan hasil multi-dimensi?

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

saya mengharapkan

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

Anda punya ide yang bisa diterapkan, tetapi #flatten!ada di tempat yang salah - itu meratakan penerima, sehingga Anda bisa menggunakannya untuk berubah [1, 2, ['foo', 'bar']]menjadi [1,2,'foo','bar'].

Saya pasti lupa beberapa pendekatan, tetapi Anda dapat menggabungkan :

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

atau tambahkan / tambahkan :

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 tambahkan dan ratakan :

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

Anda cukup 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 di sini: http://ruby-doc.org/core/classes/Array.html

Pendekatan terbersih adalah dengan menggunakan metode # array concat ; 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 elemen other_ary ke diri sendiri.

Begitu

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

Array # concat tidak akan meratakan array multidimensi jika dilewatkan sebagai argumen. Anda harus menanganinya 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 permata corelib kami ( https://github.com/corlewsolutions/corelib ) yang menambahkan pembantu yang berguna ke kelas inti Ruby. Secara khusus kami memiliki metode # add_all Array yang akan secara otomatis meratakan array multidimensi sebelum menjalankan concat.

Metode mudah yang berfungsi dengan versi Ruby> = 2.0 tetapi tidak dengan versi yang lebih lama:

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]

Coba ini, ini 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 "Set Union"

Berikut adalah dua cara, perhatikan dalam hal ini bahwa cara pertama menetapkan 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"]

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

Untuk menambahkan bke adan menyimpan hasilnya dalam a:

a.push(*b)

atau

a += b

Dalam kedua kasus, amenjadi:

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

tetapi dalam kasus sebelumnya, unsur-unsur bditambahkan ke aarray yang ada , dan dalam kasus yang kedua dua array digabungkan bersama-sama dan hasilnya disimpan di a.

(array1 + array2).uniq

Dengan cara ini Anda mendapatkan elemen array1 terlebih dahulu. Anda tidak akan mendapatkan duplikat.

Menguraikan jawaban @ Pilcrow satu-satunya jawaban yang cocok untuk array besar adalah concat(+ ) karena cepat dan tidak mengalokasikan objek baru untuk pengumpulan sampah saat beroperasi di dalam sebuah loop.

Inilah patokannya:

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

Seperti yang Anda lihat menggunakan pushthrows ERROR : stack level too deep (SystemStackError)ketika array cukup besar.

Pertanyaannya, pada dasarnya, adalah "bagaimana menggabungkan array di Ruby". Secara alami jawabannya adalah menggunakan concatatau+ seperti yang disebutkan dalam hampir setiap jawaban.

Sebuah ekstensi alami untuk pertanyaan adalah "bagaimana melakukan penggabungan baris 2D dari array 2D di Ruby". Ketika saya googled "ruby concatenate matrices", pertanyaan SO ini adalah hasil teratas jadi saya pikir saya akan meninggalkan jawaban saya untuk pertanyaan (tanpa diminta tetapi terkait) di sini untuk anak cucu.

Dalam beberapa aplikasi Anda mungkin ingin "menggabungkan" dua array 2D bijaksana. Sesuatu seperti,

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

Ini adalah sesuatu seperti "menambah" sebuah matriks. Sebagai contoh, saya menggunakan teknik ini untuk membuat matriks adjacency tunggal untuk mewakili grafik dari sekelompok matriks yang lebih kecil. Tanpa teknik ini saya harus beralih pada komponen dengan cara yang bisa menjadi rawan kesalahan atau frustasi untuk dipikirkan. Saya mungkin harus melakukan each_with_index, misalnya. Sebagai gantinya saya menggabungkan 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]]

Hanya cara lain untuk melakukannya.

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

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

Jika data baru bisa berupa array atau skalar, dan Anda ingin mencegah data baru untuk bersarang jika itu adalah array, operator percikan mengagumkan! Ini mengembalikan skalar untuk skalar, dan daftar argumen untuk 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 

Saya terkejut tidak ada yang disebutkan reduce, yang bekerja dengan baik ketika Anda memiliki array array:

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

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

Ini tidak akan menghapus dups, tetapi

a|b

menghapus dups.

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

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 = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray + anotherarray