somearray = ["some", "thing"]
anotherarray = ["another", "thing"]
somearray.push(anotherarray.flatten!)
Saya harapkan
["some","thing","another","thing"]
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 << a2).flatten! # a call to #flatten instead would return a new array
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.
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"]
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 <main>': stack level too deep (SystemStackError)
Seperti yang anda lihat menggunakan push
melempar ERROR: stack tingkat terlalu dalam (SystemStackError)
ketika array yang cukup besar.
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
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 << anotherarray # => ["some", "thing", ["another", "thing"]]
somearray.flatten! # => ["some", "thing", "another", "thing"]
somearray # => ["some", "thing", "another", "thing"]