คุณจะเพิ่มอาร์เรย์ไปยังอาร์เรย์อื่นใน Ruby ได้อย่างไรและไม่ได้ผลลัพธ์ที่มีหลายมิติ

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

ฉันคาดหวัง

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

คุณมีความคิดที่ใช้การได้ แต่#flatten!อยู่ในสถานที่ที่ผิด - มันทำให้เครื่องรับแบนดังนั้นคุณสามารถใช้มันเพื่อเปลี่ยน[1, 2, ['foo', 'bar']]เป็น[1,2,'foo','bar']เข้าไป

ฉันลืมวิธีการบางอย่างได้อย่างไม่ต้องสงสัย แต่คุณสามารถต่อกันได้:

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

หรือ / ต่อท้าย :

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

หรือ ประกบกัน :

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

หรือผนวกและเรียบ :

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

คุณสามารถใช้+โอเปอเรเตอร์ได้!

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]

คุณสามารถอ่านทั้งหมดเกี่ยวกับคลาสอาเรย์ได้ที่นี่: http://ruby-doc.org/core/classes/Array.html

วิธีที่สะอาดที่สุดคือการใช้ Array # concatวิธี; มันจะไม่สร้างอาร์เรย์ใหม่ (ต่างจาก Array # + ซึ่งจะทำสิ่งเดียวกัน แต่สร้างอาร์เรย์ใหม่)

ส่งตรงจากเอกสาร ( http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat ):

concat (other_ary)

ผนวกองค์ประกอบของ other_ary เข้ากับตนเอง

ดังนั้น

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

Array # concatจะไม่แบนอาร์เรย์หลายมิติถ้ามันถูกส่งผ่านเป็นอาร์กิวเมนต์ คุณจะต้องจัดการแยกต่างหาก:

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

สุดท้ายคุณสามารถใช้อัญมณี Corelib ของเรา ( https://github.com/corlewsolutions/corelib ) ซึ่งเพิ่มผู้ช่วยเหลือที่มีประโยชน์ให้กับคลาสทับทิมหลัก โดยเฉพาะอย่างยิ่งเรามีวิธีArray # add_allซึ่งจะแผ่อาร์เรย์หลายมิติโดยอัตโนมัติก่อนที่จะทำการเชื่อมต่อ

วิธีง่าย ๆ ที่ทำงานกับ Ruby version> = 2.0 แต่ไม่ใช่กับรุ่นเก่ากว่า:

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]

ลองสิ่งนี้มันจะรวมอาร์เรย์ของคุณเพื่อลบรายการที่ซ้ำกัน

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

array3 = array1|array2

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

เอกสารเพิ่มเติมดูที่ "Set Union"

นี่คือสองวิธีสังเกตในกรณีนี้ว่าวิธีแรกกำหนดอาเรย์ใหม่ (แปลเป็น somearray = somearray + Somarray อีกครั้ง)

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

ที่จะผนวกbการaและเก็บผลในa:

a.push(*b)

หรือ

a += b

ไม่ว่าในกรณีใดaจะกลายเป็น:

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

แต่ในกรณีที่อดีตองค์ประกอบของbถูกผนวกเข้ากับที่มีอยู่อาร์เรย์และในกรณีหลังทั้งสองอาร์เรย์จะตัดแบ่งกันและผลที่ได้จะถูกเก็บไว้ในaa

(array1 + array2).uniq

วิธีนี้คุณจะได้รับองค์ประกอบ array1 ก่อน คุณจะไม่ได้รับข้อมูลซ้ำซ้อน

อธิบายอย่างละเอียดในคำตอบของ @ Pilcrow คำตอบที่เหมาะสมสำหรับอาร์เรย์ขนาดใหญ่คือconcat(+ ) เนื่องจากรวดเร็วและไม่จัดสรรวัตถุใหม่เพื่อรวบรวมขยะเมื่อทำงานภายในลูป

นี่คือมาตรฐาน:

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

ผล:

       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)

ที่คุณสามารถดูโดยใช้pushพ่นข้อผิดพลาด : stack level too deep (SystemStackError)เมื่ออาร์เรย์ที่มีขนาดใหญ่พอ

คำถามหลักคือ "วิธีการเชื่อมต่ออาร์เรย์ใน Ruby" แน่นอนคำตอบคือการใช้concatหรือ+ตามที่กล่าวไว้ในเกือบทุกคำตอบ

ส่วนขยายตามธรรมชาติของคำถามจะเป็น "วิธีดำเนินการเรียงต่อแถวที่ชาญฉลาดของอาร์เรย์ 2 มิติใน Ruby" เมื่อฉัน googled "ruby concatenate matrices" คำถาม SO นี้เป็นผลลัพธ์สูงสุดดังนั้นฉันคิดว่าฉันจะทิ้งคำตอบของฉันไว้ที่คำถาม (ไม่ได้รับการถาม แต่เกี่ยวข้อง) ที่นี่เพื่อลูกหลาน

ในบางแอปพลิเคชันคุณอาจต้องการ "เชื่อมต่อกัน" สองมิติสองแถวเรียงกัน สิ่งที่ต้องการ,

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

นี่คือสิ่งที่ชอบ "การเพิ่ม" เมทริกซ์ ตัวอย่างเช่นฉันใช้เทคนิคนี้เพื่อสร้างเมทริกซ์ adjacency เดียวเพื่อแสดงกราฟจากเมทริกซ์ขนาดเล็ก หากไม่มีเทคนิคนี้ฉันจะต้องวนซ้ำส่วนประกอบต่างๆในลักษณะที่อาจทำให้เกิดข้อผิดพลาดได้ง่ายหรือหงุดหงิดที่จะคิด ฉันอาจจะต้องทำeach_with_indexเช่น แทนฉันรวมซิปและแผ่ดังต่อไปนี้

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

อีกวิธีหนึ่งในการทำมัน

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

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

หากข้อมูลใหม่อาจเป็นอาเรย์หรือสเกลาร์และคุณต้องการป้องกันไม่ให้ข้อมูลใหม่ซ้อนกันถ้าเป็นอาเรย์ตัวดำเนินการที่น่าประทับใจ! ส่งคืนสเกลาร์สำหรับสเกลาร์และรายการอาร์กิวเมนต์ที่ไม่ได้แพ็คสำหรับอาร์เรย์

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 

ฉันประหลาดใจที่ไม่มีใครพูดถึงreduceซึ่งทำงานได้ดีเมื่อคุณมีอาร์เรย์:

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

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

สิ่งนี้จะไม่ลบ dups ออก

a|b

ลบ dups

ฉันพบว่ามันง่ายกว่าที่จะผลักดันหรือผนวกอาร์เรย์แล้วเรียบให้เข้าที่เช่น:

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 = ["บางคน", "สิ่ง"]

anotherarray = ["อีก", "สิ่ง"]

somearray + Anotherarray