Làm thế nào để bạn thêm một mảng vào một mảng khác trong Ruby và không kết thúc với kết quả đa chiều?

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

Tôi mong đợi

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

Bạn đã có một ý tưởng khả thi, nhưng #flatten!nó ở sai vị trí - nó làm phẳng bộ thu của nó, vì vậy bạn có thể sử dụng nó để biến [1, 2, ['foo', 'bar']]thành [1,2,'foo','bar'].

Tôi chắc chắn đã quên một số cách tiếp cận, nhưng bạn có thể nối lại :

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

hoặc thêm / nối thêm :

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

hoặc mối nối :

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

hoặc chắp thêm và làm phẳng :

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

Bạn chỉ có thể sử dụng các +nhà điều hành!

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]

Bạn có thể đọc tất cả về lớp mảng ở đây: http://ruby-doc.org/core/groupes/Array.html

Cách tiếp cận sạch nhất là sử dụng Array # concat phương thức ; nó sẽ không tạo ra một mảng mới (không giống như Array # + sẽ làm điều tương tự nhưng tạo ra một mảng mới).

Trực tiếp từ các tài liệu ( http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat ):

concat (other_ary)

Nối các phần tử của other_ary vào chính nó.

Vì thế

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

Mảng # concat sẽ không làm phẳng một mảng nhiều chiều nếu nó được truyền vào dưới dạng đối số. Bạn sẽ cần xử lý riêng điều đó:

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

Cuối cùng, bạn có thể sử dụng đá quý corelib của chúng tôi ( https://github.com/corlewsolutions/corelib ) để thêm các trợ giúp hữu ích cho các lớp lõi Ruby. Cụ thể, chúng ta có một phương thức Array # add_all sẽ tự động làm phẳng các mảng nhiều chiều trước khi thực hiện concat.

Phương pháp dễ dàng hoạt động với phiên bản Ruby> = 2.0 nhưng không phải với phiên bản cũ hơn:

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]

Hãy thử điều này, nó sẽ kết hợp các mảng của bạn loại bỏ trùng lặp

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

array3 = array1|array2

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

Xem thêm tài liệu tại "Set Union"

Dưới đây là hai cách, lưu ý trong trường hợp này là cách đầu tiên gán một mảng mới (dịch thành 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"]

Để thêm bvào avà lưu trữ kết quả trong a:

a.push(*b)

hoặc là

a += b

Trong cả hai trường hợp, atrở thành:

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

nhưng trong trường hợp trước, các phần tử của bđược gắn vào amảng hiện có và trong trường hợp sau, hai mảng được nối với nhau và kết quả được lưu trữ trong a.

(array1 + array2).uniq

Bằng cách này bạn có được các phần tử mảng1 trước. Bạn sẽ không nhận được bản sao.

Xây dựng câu trả lời của @ Pilcrow, câu trả lời phù hợp duy nhất cho các mảng lớn là concat(+ ) vì nó nhanh và không phân bổ một đối tượng mới được thu gom rác khi hoạt động trong một vòng lặp.

Đây là điểm chuẩn:

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

Các kết quả:

       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)

Như bạn có thể thấy bằng cách sử dụng pushném L ERI : stack level too deep (SystemStackError)khi các mảng đủ lớn.

Câu hỏi, về cơ bản, là "làm thế nào để ghép các mảng trong Ruby". Đương nhiên câu trả lời là sử dụng concathoặc+ như đã đề cập trong gần như mọi câu trả lời.

Một phần mở rộng tự nhiên cho câu hỏi sẽ là "làm thế nào để thực hiện nối hàng khôn ngoan các mảng 2D trong Ruby". Khi tôi googled "ma trận kết hợp ruby", câu hỏi SO này là kết quả hàng đầu vì vậy tôi nghĩ rằng tôi sẽ để lại câu trả lời của mình cho câu hỏi đó (không được nêu nhưng có liên quan) ở đây cho hậu thế.

Trong một số ứng dụng, bạn có thể muốn "nối" hai mảng 2D theo hàng. Cái gì đó như,

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

Đây là một cái gì đó giống như "tăng cường" một ma trận. Ví dụ, tôi đã sử dụng kỹ thuật này để tạo một ma trận kề, để biểu diễn một đồ thị trong một loạt các ma trận nhỏ hơn. Nếu không có kỹ thuật này, tôi sẽ phải lặp đi lặp lại các thành phần theo cách có thể dễ bị lỗi hoặc bực bội khi nghĩ về. Tôi có thể đã phải làm một each_with_indexví dụ. Thay vào đó tôi kết hợp zip và làm phẳng như sau,

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

Chỉ là một cách khác để làm điều đó.

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

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

Nếu dữ liệu mới có thể là một mảng hoặc vô hướng và bạn muốn ngăn dữ liệu mới được lồng nếu nó là một mảng, toán tử splat là tuyệt vời! Nó trả về một vô hướng cho một vô hướng và một danh sách các đối số được giải nén cho một mảng.

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 

Tôi ngạc nhiên không ai đã đề cập reduce, hoạt động tốt khi bạn có một mảng các mảng:

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

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

Điều này sẽ không loại bỏ dups, nhưng

a|b

loại bỏ dups.

Tôi thấy dễ dàng hơn để đẩy hoặc nối các mảng và sau đó làm phẳng chúng tại chỗ, như vậy:

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 = ["một số", "điều"]

Anotherarray = ["khác", "điều"]

somearray + otherarray