Wie fügt man einem anderen Array in Ruby ein Array hinzu und erhält kein mehrdimensionales Ergebnis?

somearray = ["some", "thing"]

anotherarray = ["another", "thing"]

somearray.push(anotherarray.flatten!)

Ich erwartete

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

Sie haben eine praktikable Idee, aber das #flatten!ist an der falschen Stelle - es seinen Empfänger verflacht, so dass Sie, um sie nutzen könnten [1, 2, ['foo', 'bar']]in [1,2,'foo','bar'].

Ich vergesse zweifellos einige Ansätze, aber Sie können verketten :

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

oder voranstellen / anhängen :

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

oder Spleiß :

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

oder anhängen und abflachen :

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

Sie können einfach den +Operator verwenden!

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]

Sie können alles über die Array-Klasse hier lesen: http://ruby-doc.org/core/classes/Array.html

Der sauberste Ansatz ist die Verwendung der Array # concat- Methode. Es wird kein neues Array erstellt (im Gegensatz zu Array # +, das dasselbe tut, aber ein neues Array erstellt).

Direkt aus den Dokumenten ( http://www.ruby-doc.org/core-1.9.3/Array.html#method-i-concat ):

concat (other_ary)

Hängt die Elemente von other_ary an self an.

Damit

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

Array # concat reduziert ein mehrdimensionales Array nicht, wenn es als Argument übergeben wird. Sie müssen das separat behandeln:

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

Zuletzt können Sie unser Corelib-Juwel ( https://github.com/corlewsolutions/corelib ) verwenden, das den Ruby- Kernklassen nützliche Helfer hinzufügt. Insbesondere haben wir eine Array # add_all- Methode, die mehrdimensionale Arrays automatisch reduziert, bevor der Concat ausgeführt wird.

Einfache Methode, die mit Ruby Version> = 2.0 funktioniert, aber nicht mit älteren Versionen:

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]

Versuchen Sie dies, es kombiniert Ihre Arrays und entfernt Duplikate

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

array3 = array1|array2

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

Weitere Dokumentation unter "Set Union"

Hier sind zwei Möglichkeiten: Beachten Sie in diesem Fall, dass die erste Möglichkeit ein neues Array zuweist (übersetzt in 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"]

So hängen Sie das Ergebnis ban aund speichern es in a:

a.push(*b)

oder

a += b

In beiden Fällen awird:

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

Im ersteren Fall werden die Elemente von ban das vorhandene aArray angehängt , und im letzteren Fall werden die beiden Arrays miteinander verkettet und das Ergebnis in gespeichert a.

(array1 + array2).uniq

Auf diese Weise erhalten Sie zuerst array1-Elemente. Sie erhalten keine Duplikate.

Bei der Ausarbeitung der Antwort von @ Pilcrow ist die einzige geeignete Antwort für große Arrays concat( +), da sie schnell ist und kein neues Objekt zuweist, das beim Betrieb innerhalb einer Schleife durch Müll gesammelt werden soll.

Hier ist der 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

Ergebnisse:

       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)

Wie Sie mit einem pushWurf sehen können, gibt es einen FEHLER : stack level too deep (SystemStackError)Wenn die Arrays groß genug sind.

Die Frage ist im Wesentlichen, wie Arrays in Ruby verkettet werden. Natürlich ist die Antwort zu verwenden concatoder +wie in fast jeder Antwort erwähnt.

Eine natürliche Erweiterung der Frage wäre "wie eine zeilenweise Verkettung von 2D-Arrays in Ruby durchgeführt wird". Als ich "Ruby Concatenate Matrices" googelte, war diese SO-Frage das Top-Ergebnis, also dachte ich, ich würde meine Antwort auf diese (nicht gestellte, aber verwandte) Frage hier der Nachwelt überlassen.

In einigen Anwendungen möchten Sie möglicherweise zwei 2D-Arrays zeilenweise "verketten". Etwas wie,

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

Dies ist so etwas wie das "Erweitern" einer Matrix. Mit dieser Technik habe ich beispielsweise eine einzelne Adjazenzmatrix erstellt, um einen Graphen aus einer Reihe kleinerer Matrizen darzustellen. Ohne diese Technik hätte ich die Komponenten auf eine Weise durchlaufen müssen, die fehleranfällig oder frustrierend gewesen wäre. Ich hätte each_with_indexzum Beispiel eine machen müssen. Stattdessen habe ich Reißverschluss und Abflachung wie folgt kombiniert :

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

Nur eine andere Art, es zu tun.

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

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

Wenn die neuen Daten ein Array oder ein Skalar sein könnten und Sie verhindern möchten, dass die neuen Daten verschachtelt werden, wenn es sich um ein Array handelt, ist der Splat-Operator fantastisch! Es gibt einen Skalar für einen Skalar und eine entpackte Liste von Argumenten für ein Array zurück.

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 

Ich bin überrascht, dass niemand erwähnt hat reduce, was gut funktioniert, wenn Sie eine Reihe von Arrays haben:

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

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

Dies wird keine Dups entfernen, aber

a|b

Entfernt Dups.

Ich finde es einfacher, Arrays zu verschieben oder anzuhängen und sie dann wie folgt zu glätten:

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 = ["etwas", "Ding"]

anotherarray = ["ein anderes", "Ding"]

Somearray + Anotherarray